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

package/android/src/main/java/cgmblelib/utils/SharedPreferencesLibraryUtil.java

@@ -10,60 +10,82 @@ import cgmblelib.qr.QRInformation;
 
 public class SharedPreferencesLibraryUtil {
 
-  BSharedPreferences prefsHelper;
-  private final String QRInfo = "QRInformation";
-  private final String SyncMeta = "SyncMeta";
+    BSharedPreferences prefsHelper;
+    private final String QRInfo = "QRInformation";
+    private final String SyncMeta = "SyncMeta";
+    private final String PatientId = "PatientId";
 
 
-  public SharedPreferencesLibraryUtil(Context context) {
-    prefsHelper = BSharedPreferences.getInstance(context);
-  }
+    public SharedPreferencesLibraryUtil(Context context) {
+        prefsHelper = BSharedPreferences.getInstance(context);
+    }
+
+    public QRInformation getQRInformation() {
+        try {
+            String message = prefsHelper.getData(QRInfo);
+            if (message == null || message.isEmpty()) {
+                return null;
+            }
+            return new Gson().fromJson(message, QRInformation.class);
+        } catch (Exception e) {
+            Log.d("Error => ", "getQRInformation: " + e.getMessage());
+            return null;
+        }
+    }
 
-  public QRInformation getQRInformation() {
-    try {
-      String message = prefsHelper.getData(QRInfo);
-      if (message == null || message.isEmpty()) {
-        return null;
-      }
-      return new Gson().fromJson(message, QRInformation.class);
-    } catch (Exception e) {
-      Log.d("Error => ", "getQRInformation: " + e.getMessage());
-      return null;
+
+    public void setQRInformation(String transmitterName, String qrmessage, float K, float R, String sensor) {
+        try {
+            Log.d("Error => ", "setQRInformation: " + transmitterName + qrmessage + K + R + sensor);
+            prefsHelper.saveData(QRInfo, new Gson().toJson(new QRInformation(transmitterName, qrmessage, R, K, sensor)));
+        } catch (Exception e) {
+            Log.d("Error => ", "setQRInformation: " + e.getMessage());
+        }
     }
-  }
 
+    public void setLastSyncData(SyncMeta syncMeta) {
+        try {
+            prefsHelper.saveData(SyncMeta, new Gson().toJson(syncMeta));
+        } catch (Exception e) {
+            Log.d("Error => ", "setLastSyncData: " + e.getMessage());
+        }
+    }
 
-  public void setQRInformation(String transmitterName, String qrmessage, float K, float R, String sensor) {
-    try {
-      Log.d("Error => ", "setQRInformation: " + transmitterName + qrmessage + K + R + sensor);
-      prefsHelper.saveData(QRInfo, new Gson().toJson(new QRInformation(transmitterName, qrmessage, R, K, sensor)));
-    } catch (Exception e) {
-      Log.d("Error => ", "setQRInformation: " + e.getMessage());
+    public SyncMeta getLastSyncData() {
+        try {
+            String message = prefsHelper.getData(SyncMeta);
+            if (message == null || message.isEmpty()) {
+                return null;
+            }
+            return new Gson().fromJson(message, SyncMeta.class);
+        } catch (Exception e) {
+            Log.d("Error => ", "getLastSyncData: " + e.getMessage());
+            return null;
+        }
     }
-  }
 
-  public void setLastSyncData(SyncMeta syncMeta) {
-    try {
-      prefsHelper.saveData(SyncMeta, new Gson().toJson(syncMeta));
-    } catch (Exception e) {
-      Log.d("Error => ", "setLastSyncData: " + e.getMessage());
+    public void setLastPatientId(String patientId) {
+        try {
+            prefsHelper.saveData(PatientId, patientId);
+        } catch (Exception e) {
+            Log.d("Error => ", "setLastUserId: " + e.getMessage());
+        }
     }
-  }
 
-  public SyncMeta getLastSyncData() {
-    try {
-      String message = prefsHelper.getData(SyncMeta);
-      if (message == null || message.isEmpty()) {
-        return null;
-      }
-      return new Gson().fromJson(message, SyncMeta.class);
-    } catch (Exception e) {
-      Log.d("Error => ", "getLastSyncData: " + e.getMessage());
-      return null;
+    public String getLastPatientId() {
+        try {
+            String message = prefsHelper.getData(PatientId);
+            if (message == null || message.isEmpty()) {
+                return null;
+            }
+            return message;
+        } catch (Exception e) {
+            Log.d("Error => ", "getLastUserId: " + e.getMessage());
+            return null;
+        }
     }
-  }
 
-  public void clearQRInformation() {
-    prefsHelper.saveData(QRInfo, null);
-  }
+    public void clearQRInformation() {
+        prefsHelper.saveData(QRInfo, null);
+    }
 }

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

@@ -2,15 +2,10 @@ package com.mytatvarnsdk
 
 import android.app.Application
 import android.bluetooth.BluetoothAdapter
-import android.bluetooth.BluetoothManager
-import android.content.Context
 import android.content.Intent
-import android.content.pm.PackageManager
-import android.os.Build
 import android.os.Handler
 import android.os.Looper
 import android.util.Log
-import androidx.core.content.ContextCompat
 import androidx.lifecycle.Observer
 import androidx.lifecycle.ViewModelProvider
 import androidx.lifecycle.ViewModelStore
@@ -31,9 +26,6 @@ import com.facebook.react.modules.core.DeviceEventManagerModule
 import com.google.gson.Gson
 import com.google.gson.GsonBuilder
 import com.mytatvarnsdk.activity.HelpActivity
-import com.mytatvarnsdk.activity.PermissionActivity
-import com.mytatvarnsdk.activity.PermissionUtils
-import com.mytatvarnsdk.activity.SearchTransmitterActivity
 import com.mytatvarnsdk.activity.StartCGMActivity
 import com.mytatvarnsdk.model.AllCGMLogRequest
 import com.mytatvarnsdk.model.CgmLog
@@ -94,6 +86,7 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
     companion object {
         var mReactContext: ReactApplicationContext? = null
         var userToken: String = ""
+        var env: String = ""
     }
 
     override fun getName(): String {
@@ -101,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
@@ -112,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())
                     }
                 }
@@ -123,9 +117,15 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
     }
 
     @ReactMethod
-    fun observeTransmitterUnbindStatus(token: String, apiResponse: String?) {
+    fun observeTransmitterUnbindStatus(
+        token: String,
+        apiResponse: String?,
+        patientId: String,
+        envType: String
+    ) {
         try {
             if (apiResponse != null && apiResponse.isNotEmpty()) {
+                env = envType
                 userToken = token
 
                 /*authenticateSDKService.getCGMData(
@@ -192,6 +192,15 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                     val startDate = sensor.startDate
                     val endDate = sensor.endDate
                     val sensorId = sensor.sensorId
+                    val currentPatientId = patientId
+
+                    val lastPatientId = prefsHelper.lastPatientId
+                    val lastSensorId = prefsHelper.qrInformation.sensor
+
+                    if (lastPatientId != null && lastSensorId != null && (lastPatientId != currentPatientId || lastSensorId != sensorId)) {
+                        mModel.clearAllGlucoseAndDeviceData()
+                        return
+                    }
 
                     if (isCurrentDateInRange(startDate, endDate)) {
                         println("Current date is in range")
@@ -204,14 +213,17 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                                 postEventDataToAPI(
                                     pocDevice,
                                     DeviceStatus.TRANSMITTER_DISCONNECT.id,
-                                    pocDevice.qrMessage
+                                    pocDevice.qrMessage, envType
                                 )
+                            } else {
+                                prefsHelper.lastPatientId = currentPatientId
+                                prefsHelper.qrInformation.sensor = sensorId
                             }
                         } else {
                             postEventDataToAPI(
                                 pocDevice,
                                 DeviceStatus.TRANSMITTER_DISCONNECT.id,
-                                sensorId
+                                sensorId, envType
                             )
                         }
 
@@ -231,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()
@@ -257,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
 
@@ -270,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) {
@@ -279,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) {
@@ -301,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 {
@@ -324,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)
@@ -346,7 +368,7 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
     }
 
     @ReactMethod
-    fun reconnectCgmTracky(token: String) {
+    fun reconnectCgmTracky(token: String, envType: String) {
         try {
             userToken = token
             currentActivity?.startActivity(
@@ -372,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) {
@@ -416,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"
@@ -426,7 +449,7 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                     } else {
 
                         Handler(Looper.getMainLooper()).postDelayed({
-                            observeAllGlucoseData(userToken)
+                            observeAllGlucoseData(userToken, isForClear, envType)
                         }, 100)
                         Log.d(
                             "observeGlucoseData",
@@ -459,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) {
@@ -483,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 {
@@ -505,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}")
@@ -514,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) {
@@ -546,7 +569,7 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                     }
                 }
 
-                postEventDataToAPI(it, statusId, it.qrMessage)
+                postEventDataToAPI(it, statusId, it.qrMessage, envType)
             } ?: run {
                 Log.e(
                     "handleGlucoseError",
@@ -559,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")
@@ -643,7 +680,7 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                         "processBatchDataAndStartObserver",
                         "Starting live observer after batch completion"
                     )
-                    observeGlucoseData(userToken)
+                    observeGlucoseData(userToken, isForClear, envType)
                 } else {
                     Log.d(
                         "processBatchDataAndStartObserver",
@@ -658,7 +695,7 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
             isBatchProcessing = false
             withContext(Dispatchers.Main) {
                 if (!isObserving) {
-                    observeGlucoseData(userToken)
+                    observeGlucoseData(userToken, isForClear, envType)
                 }
             }
         }
@@ -694,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
@@ -762,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()
@@ -789,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)
             }
         }
 
@@ -838,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/MainApplication.kt

@@ -39,8 +39,8 @@ class MainApplication : BApplication(), ReactApplication {
     super.onCreate()
     Log.d("MainApplication", "MainApplication onCreate called")
     SoLoader.init(this, false)
-    BleService.startService(this)
-    BSharedPreferences.init(this)
+//    BleService.startService(this)
+//    BSharedPreferences.init(this)
   }
 
   override fun getReactNativeHost(): ReactNativeHost {

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")
             )
         }