react-native-mytatva-rn-sdk 1.2.52 → 1.2.53

package/android/src/main/java/com/mytatvarnsdk/CgmTrackyLibModule.kt

@@ -86,6 +86,7 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
     companion object {
         var mReactContext: ReactApplicationContext? = null
         var userToken: String = ""
+        var env: String = ""
     }
 
     override fun getName(): String {
@@ -93,9 +94,10 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
     }
 
     @ReactMethod
-    fun observeDeviceStatus(token: String) {
+    fun observeDeviceStatus(token: String, envType: String) {
         try {
             userToken = token
+            env = envType
 
             // Reset previous state
             lastDeviceStatus = null
@@ -104,7 +106,7 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
             Handler(Looper.getMainLooper()).post {
                 mModel.device.observeForever { device ->
                     if (device != null) {
-                        postEventDataToAPI(device, "", device.qrMessage ?: "")
+                        postEventDataToAPI(device, "", device.qrMessage ?: "", envType)
                         Log.d("observeDeviceStatus: ", device.toString())
                     }
                 }
@@ -115,9 +117,15 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
     }
 
     @ReactMethod
-    fun observeTransmitterUnbindStatus(token: String, apiResponse: String?, patientId: String) {
+    fun observeTransmitterUnbindStatus(
+        token: String,
+        apiResponse: String?,
+        patientId: String,
+        envType: String
+    ) {
         try {
             if (apiResponse != null && apiResponse.isNotEmpty()) {
+                env = envType
                 userToken = token
 
                 /*authenticateSDKService.getCGMData(
@@ -205,7 +213,7 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                                 postEventDataToAPI(
                                     pocDevice,
                                     DeviceStatus.TRANSMITTER_DISCONNECT.id,
-                                    pocDevice.qrMessage
+                                    pocDevice.qrMessage, envType
                                 )
                             } else {
                                 prefsHelper.lastPatientId = currentPatientId
@@ -215,7 +223,7 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                             postEventDataToAPI(
                                 pocDevice,
                                 DeviceStatus.TRANSMITTER_DISCONNECT.id,
-                                sensorId
+                                sensorId, envType
                             )
                         }
 
@@ -235,7 +243,12 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
     private var isDebounceTimerActive: Boolean = false
 
 
-    private fun postEventDataToAPI(device: PocDevice?, mStatus: String, sensorId: String?) {
+    private fun postEventDataToAPI(
+        device: PocDevice?,
+        mStatus: String,
+        sensorId: String?,
+        envType: String
+    ) {
         apiScope.launch {
             try {
                 val bluetoothAdapter: BluetoothAdapter? = BluetoothAdapter.getDefaultAdapter()
@@ -261,7 +274,7 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                     debounceDeviceTimer?.schedule(object : TimerTask() {
                         override fun run() {
                             isDebounceTimerActive = false
-                            callEventAPI(device, status, sensorId)
+                            callEventAPI(device, status, sensorId, envType)
                         }
                     }, 1 * 60 * 1000) // 1 minutes in milliseconds
 
@@ -274,7 +287,7 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
 
                     Log.d("Debounce", "Timer cancelled, event triggered immediately")
 
-                    callEventAPI(device, status, sensorId)
+                    callEventAPI(device, status, sensorId, envType)
                 }
 
             } catch (e: Exception) {
@@ -283,7 +296,12 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
         }
     }
 
-    private fun callEventAPI(device: PocDevice?, status: String, sensorId: String?) {
+    private fun callEventAPI(
+        device: PocDevice?,
+        status: String,
+        sensorId: String?,
+        envType: String
+    ) {
         Log.d("Device event Status", "Last Device event lastDeviceStatus API: $lastDeviceStatus")
 
         if (status.isNotEmpty() && status != lastDeviceStatus) {
@@ -305,7 +323,7 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
             }
 
             authenticateSDKService.postDeviceData(
-                environment = TATVA_ENVIRONMENT.PROD,
+                environment = if (envType.lowercase() == "uat") TATVA_ENVIRONMENT.STAGE else TATVA_ENVIRONMENT.PROD,
                 data = obj.toString(),
                 token = userToken,
                 loaderListener = object : LoaderListener {
@@ -328,7 +346,7 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
     }
 
     @ReactMethod
-    fun startCgmTracky(token: String) {
+    fun startCgmTracky(token: String, envType: String) {
         try {
             userToken = token
             val intent = Intent(currentActivity, StartCGMActivity::class.java)
@@ -350,7 +368,7 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
     }
 
     @ReactMethod
-    fun reconnectCgmTracky(token: String) {
+    fun reconnectCgmTracky(token: String, envType: String) {
         try {
             userToken = token
             currentActivity?.startActivity(
@@ -376,9 +394,10 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
 
 
     @ReactMethod
-    fun observeGlucoseData(token: String) {
+    fun observeGlucoseData(token: String, isForClear: Boolean = false, envType: String) {
         try {
             userToken = token
+            env = envType
 
             // Ensure we're not already observing
             if (isObserving && glucoseObserver != null) {
@@ -420,7 +439,7 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                     }
 
                     if ((pocGlucose != null && lastSyncData == null) || (pocGlucose != null && lastSyncData != null && dataAge <= 4 * 60 * 1000L)) {
-                        handleGlucoseData(pocGlucose)
+                        handleGlucoseData(pocGlucose, envType)
                         Log.d(
                             "observeGlucoseData",
                             "Received glucose data - processing"
@@ -430,7 +449,7 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                     } else {
 
                         Handler(Looper.getMainLooper()).postDelayed({
-                            observeAllGlucoseData(userToken)
+                            observeAllGlucoseData(userToken, isForClear, envType)
                         }, 100)
                         Log.d(
                             "observeGlucoseData",
@@ -463,7 +482,7 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
         }
     }
 
-    private fun handleGlucoseData(pocGlucose: PocGlucose) {
+    private fun handleGlucoseData(pocGlucose: PocGlucose, envType: String) {
         try {
             // Additional safety check
             if (pocGlucose.glucoseId == null) {
@@ -487,7 +506,7 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                     Log.d("Glucose data 3 min==> ", "Glucose data 3 min==> final Json: $json")
 
                     authenticateSDKService.postCGMData(
-                        environment = TATVA_ENVIRONMENT.PROD,
+                        environment = if (envType.lowercase() == "uat") TATVA_ENVIRONMENT.STAGE else TATVA_ENVIRONMENT.PROD,
                         data = json,
                         token = userToken,
                         responseListener = object : AuthenticateSDKService.ResponseListener {
@@ -509,7 +528,7 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                 }
             } else {
                 Log.d("handleGlucoseData", "Glucose data has error: ${pocGlucose.errorCode}")
-                handleGlucoseError(pocGlucose)
+                handleGlucoseError(pocGlucose, envType)
             }
         } catch (e: Exception) {
             Log.e("handleGlucoseData", "Error handling glucose data: ${e.message}")
@@ -518,7 +537,7 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
     }
 
     // Extract error handling logic
-    private fun handleGlucoseError(pocGlucose: PocGlucose) {
+    private fun handleGlucoseError(pocGlucose: PocGlucose, envType: String) {
         try {
             // Additional safety check for deviceId
             if (pocGlucose.deviceId == null) {
@@ -550,7 +569,7 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                     }
                 }
 
-                postEventDataToAPI(it, statusId, it.qrMessage)
+                postEventDataToAPI(it, statusId, it.qrMessage, envType)
             } ?: run {
                 Log.e(
                     "handleGlucoseError",
@@ -563,75 +582,89 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
         }
     }
 
-
     @ReactMethod
-    fun observeAllGlucoseData(token: String) {
+    fun observeAllGlucoseData(token: String, isForClear: Boolean = false, envType: String) {
         Log.d("function call", "observeAllGlucoseData")
+
         if (isBatchProcessing) {
             Log.d("observeAllGlucoseData", "Batch processing in progress, skipping duplicate call")
             return
         }
-        userToken = token
-
-        // FIX: Ensure proper cleanup and reset state
-        stopObservingGlucoseData()
-
-        // Add a small delay to ensure cleanup is complete
-        Handler(Looper.getMainLooper()).postDelayed({
-            try {
-                val lastSyncData = prefsHelper.lastSyncData
-                Log.d("lastSyncData: ", Gson().toJson(lastSyncData).toString())
-                val currentTime = System.currentTimeMillis()
-                var dataAge = System.currentTimeMillis()
-
-                if (prefsHelper.lastSyncData != null) {
-                    dataAge = currentTime - prefsHelper.lastSyncData.timeInMillis
-                }
-
-                if (lastSyncData != null && dataAge > 3 * 60 * 1000L) {
-                    isBatchProcessing = true
-                    CoroutineScope(Dispatchers.IO).launch {
-
-                        val glucoseData = mModel.getGlucoseBetweenTime(lastSyncData.timeInMillis)
 
+        userToken = token
+        env = envType
 
-                        Log.d("observeAllGlucoseData: ", glucoseData.toString())
-                        Log.d("Last sync time: ", lastSyncData.lastSyncTime.toString())
-                        Log.d("current time: ", System.currentTimeMillis().toString())
+        CoroutineScope(Dispatchers.IO).launch {
+            // Step 1: Clear DB first if needed
+            if (isForClear) {
+                mModel.clearAllGlucoseAndDeviceData() // suspend or blocking DB operation
+            }
 
-                        if (glucoseData != null && glucoseData.isNotEmpty()) {
-                            processBatchDataAndStartObserver(glucoseData)
-                        } else {
-                            Log.d(
-                                "observeAllGlucoseData",
-                                "No historical data found, starting live observation"
-                            )
+            // Step 2: Back to main thread to stop observers and proceed
+            withContext(Dispatchers.Main) {
+                stopObservingGlucoseData()
 
-                            withContext(Dispatchers.Main) {
-                                observeGlucoseData(userToken)
+                Handler(Looper.getMainLooper()).postDelayed({
+                    try {
+                        val lastSyncData = prefsHelper.lastSyncData
+                        Log.d("lastSyncData: ", Gson().toJson(lastSyncData).toString())
+
+                        val currentTime = System.currentTimeMillis()
+                        val dataAge =
+                            if (lastSyncData != null) currentTime - lastSyncData.timeInMillis else 0L
+
+                        if (lastSyncData != null && dataAge > 3 * 60 * 1000L) {
+                            isBatchProcessing = true
+                            CoroutineScope(Dispatchers.IO).launch {
+                                val glucoseData =
+                                    mModel.getGlucoseBetweenTime(lastSyncData.timeInMillis)
+
+                                Log.d("observeAllGlucoseData: ", glucoseData.toString())
+                                Log.d("Last sync time: ", lastSyncData.lastSyncTime.toString())
+                                Log.d("current time: ", System.currentTimeMillis().toString())
+
+                                if (!glucoseData.isNullOrEmpty()) {
+                                    processBatchDataAndStartObserver(
+                                        glucoseData,
+                                        isForClear,
+                                        envType
+                                    )
+                                } else {
+                                    Log.d(
+                                        "observeAllGlucoseData",
+                                        "No historical data found, starting live observation"
+                                    )
+                                    withContext(Dispatchers.Main) {
+                                        observeGlucoseData(userToken, isForClear, envType)
+                                    }
+                                }
                             }
+                        } else {
+                            isBatchProcessing = false
+                            observeGlucoseData(userToken, isForClear, envType)
                         }
+                    } catch (e: Exception) {
+                        isBatchProcessing = false
+                        observeGlucoseData(userToken, isForClear, envType)
                     }
-                } else {
-                    isBatchProcessing = false
-                    observeGlucoseData(userToken)
-                }
-            } catch (e: Exception) {
-                isBatchProcessing = false
-                observeGlucoseData(userToken)
+                }, 100)
             }
-        }, 100) // Small delay to ensure cleanup
+        }
     }
 
     // New method to handle batch processing and ensure proper sequencing
-    private suspend fun processBatchDataAndStartObserver(dataList: List<PocGlucose>) {
+    private suspend fun processBatchDataAndStartObserver(
+        dataList: List<PocGlucose>,
+        isForClear: Boolean = false,
+        envType: String
+    ) {
         try {
             Log.d(
                 "processBatchDataAndStartObserver",
                 "Starting batch processing with ${dataList.size} records"
             )
 
-            val success = processBatchDataSynchronously(dataList)
+            val success = processBatchDataSynchronously(dataList, envType)
 
             if (success) {
                 Log.d("processBatchDataAndStartObserver", "Batch processing completed successfully")
@@ -647,7 +680,7 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                         "processBatchDataAndStartObserver",
                         "Starting live observer after batch completion"
                     )
-                    observeGlucoseData(userToken)
+                    observeGlucoseData(userToken, isForClear, envType)
                 } else {
                     Log.d(
                         "processBatchDataAndStartObserver",
@@ -662,7 +695,7 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
             isBatchProcessing = false
             withContext(Dispatchers.Main) {
                 if (!isObserving) {
-                    observeGlucoseData(userToken)
+                    observeGlucoseData(userToken, isForClear, envType)
                 }
             }
         }
@@ -698,7 +731,10 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
     }
 
     // Updated batch processing method with better sync control
-    private suspend fun processBatchDataSynchronously(dataList: List<PocGlucose>): Boolean {
+    private suspend fun processBatchDataSynchronously(
+        dataList: List<PocGlucose>,
+        envType: String
+    ): Boolean {
         if (dataList.isEmpty()) {
             Log.d("processBatchDataSynchronously", "No data to upload")
             return true
@@ -766,7 +802,7 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                 )
                 logLongJson("Batch $index JSON=>>> ", json)
 
-                val uploadSuccessful = uploadBatchSynchronously(json, index)
+                val uploadSuccessful = uploadBatchSynchronously(json, index, envType)
 
                 if (uploadSuccessful) {
                     lastSyncedRecord = batch.lastOrNull()
@@ -793,7 +829,7 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
         // Handle error status for the last processed record
         lastSyncedRecord?.let { record ->
             if (record.errorCode != enumError.NONE) {
-                handleGlucoseError(record)
+                handleGlucoseError(record, envType)
             }
         }
 
@@ -842,11 +878,15 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
     }
 
     // Helper method for synchronous batch upload
-    private suspend fun uploadBatchSynchronously(json: String, batchIndex: Int): Boolean {
+    private suspend fun uploadBatchSynchronously(
+        json: String,
+        batchIndex: Int,
+        envType: String
+    ): Boolean {
         return suspendCoroutine { continuation ->
             try {
                 authenticateSDKService.postCGMData(
-                    environment = TATVA_ENVIRONMENT.PROD,
+                    environment = if (envType.lowercase() == "uat") TATVA_ENVIRONMENT.STAGE else TATVA_ENVIRONMENT.PROD,
                     data = json,
                     token = userToken,
                     responseListener = object : AuthenticateSDKService.ResponseListener {

package/android/src/main/java/com/mytatvarnsdk/activity/ConnectSensorActivity.kt

@@ -92,7 +92,7 @@ class ConnectSensorActivity : BaseBleActivity() {
 
         binding.toolbar.btnWhatsapp.setOnClickListener {
             startActivity(
-                Intent(this, HelpActivity::class.java).putExtra("ScreenName", "Sensor Screen")
+                Intent(this, HelpActivity::class.java).putExtra("ScreenName", "Sensor page")
             )
         }
 

package/android/src/main/java/com/mytatvarnsdk/activity/PermissionActivity.kt

@@ -170,7 +170,7 @@ class PermissionActivity : BasePermissionActivity() {
         binding.toolbar.btnWhatsapp.setOnClickListener {
             startActivity(
                 Intent(this, HelpActivity::class.java)
-                    .putExtra("ScreenName", "Permission Screen")
+                    .putExtra("ScreenName", "connection journey page")
             )
         }
 

package/android/src/main/java/com/mytatvarnsdk/activity/PlaceSensorActivity.kt

@@ -62,7 +62,7 @@ class PlaceSensorActivity : AppCompatActivity() {
         binding.toolbar.btnWhatsapp.setOnClickListener {
             startActivity(
                 Intent(this, HelpActivity::class.java)
-                    .putExtra("ScreenName", "Attach Sensor Screen")
+                    .putExtra("ScreenName", "Sensor page")
             )
         }
 

package/android/src/main/java/com/mytatvarnsdk/activity/PlaceTransmitterActivity.kt

@@ -70,7 +70,7 @@ class PlaceTransmitterActivity : AppCompatActivity() {
         binding.toolbar.btnWhatsapp.setOnClickListener {
             startActivity(
                 Intent(this, HelpActivity::class.java)
-                    .putExtra("ScreenName", "Attach Transmitter Screen")
+                    .putExtra("ScreenName", "Transmitter page")
             )
         }
 

package/android/src/main/java/com/mytatvarnsdk/activity/SearchTransmitterActivity.kt

@@ -151,7 +151,7 @@ class SearchTransmitterActivity : BaseBleActivity() {
             binding.btnSupport.btnProceed.setOnClickListener {
                 startActivity(
                     Intent(this, HelpActivity::class.java)
-                        .putExtra("ScreenName", "Transmitter Screen")
+                        .putExtra("ScreenName", "Transmitter page")
                 )
             }
 
@@ -234,8 +234,7 @@ class SearchTransmitterActivity : BaseBleActivity() {
             manageErrorState(false, "")
         } else {
             sendDataToRN("", "cgm_transmitter_detection_failed")
-
-            manageErrorState(true, "")
+            manageErrorState(true, "Timeout")
         }
         Log.d("Search Transmitter Error--> ", "Search Transmitter Error--> scanEnd")
     }
@@ -326,7 +325,7 @@ class SearchTransmitterActivity : BaseBleActivity() {
         binding.toolbar.btnWhatsapp.setOnClickListener {
             startActivity(
                 Intent(this, HelpActivity::class.java)
-                    .putExtra("ScreenName", "Transmitter Screen")
+                    .putExtra("ScreenName", "Transmitter page")
             )
         }
 

package/android/src/main/java/com/mytatvarnsdk/activity/SensorConnectSuccessActivity.kt

@@ -21,6 +21,7 @@ import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.CatalystInstance
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.mytatvarnsdk.CgmTrackyLibModule
 import com.mytatvarnsdk.R
 import com.mytatvarnsdk.databinding.ActivitySensorConnectSuccessBinding
 import com.mytatvarnsdk.databinding.ExitDialogBottomsheetBinding
@@ -34,7 +35,6 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
 import org.json.JSONObject
-import com.mytatvarnsdk.CgmTrackyLibModule
 import java.text.SimpleDateFormat
 import java.util.Date
 import java.util.Locale
@@ -80,15 +80,18 @@ class SensorConnectSuccessActivity : AppCompatActivity() {
         binding.toolbar.btnWhatsapp.setOnClickListener {
             startActivity(
                 Intent(this, HelpActivity::class.java)
-                    .putExtra("ScreenName", "Sensor Screen")
+                    .putExtra("ScreenName", "Sensor page")
             )
         }
 
         binding.toolbar.btnWatchDemo.setOnClickListener {
-            sendDataToRN("","cgm_watch_demo_clicked")
+            sendDataToRN("", "cgm_watch_demo_clicked")
 
             startActivity(
-                Intent(this, VideoActivity::class.java).putExtra("VideoId", if (isForReconnect) "n_pUrFoZ1wQ" else "r5Zemc4R044")
+                Intent(this, VideoActivity::class.java).putExtra(
+                    "VideoId",
+                    if (isForReconnect) "n_pUrFoZ1wQ" else "r5Zemc4R044"
+                )
             )
         }
 
@@ -171,7 +174,7 @@ class SensorConnectSuccessActivity : AppCompatActivity() {
         obj.put("rawData", rawData)
 
         authenticateSDKService.postDeviceData(
-            environment = TATVA_ENVIRONMENT.PROD,
+            environment = if (CgmTrackyLibModule.env.lowercase() == "uat") TATVA_ENVIRONMENT.STAGE else TATVA_ENVIRONMENT.PROD,
             data = obj.toString(),
             token = CgmTrackyLibModule.userToken,
             loaderListener = object : LoaderListener {

package/android/src/main/java/com/mytatvarnsdk/activity/StartCGMActivity.kt

@@ -92,7 +92,7 @@ class StartCGMActivity : AppCompatActivity() {
         binding.toolbar.btnWhatsapp.setOnClickListener {
             startActivity(
                 Intent(this, HelpActivity::class.java)
-                    .putExtra("ScreenName", "Start CGM Screen")
+                    .putExtra("ScreenName", "connection journey page")
             )
         }