react-native-mytatva-rn-sdk 1.2.29 → 1.2.30

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

@@ -61,924 +61,730 @@ import kotlin.coroutines.suspendCoroutine
 
 @ReactModule(name = "CgmTrackyLib")
 class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
-    ReactContextBaseJavaModule(reactContext) {
-    private val mModel: MainActivityModel
-    var authenticateSDKService: AuthenticateSDKService
-    private val job = Job()
-    private val scope = CoroutineScope(Dispatchers.IO + job)
-    var prefsHelper: SharedPreferencesLibraryUtil
-    private val apiScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
-    private var debounceJob: Job? = null
-    private var lastDeviceStatus: PocDevice? = null
-
-    private var glucoseObserver: Observer<PocGlucose?>? = null
-    private var isObserving = false
-
-    init {
-        mReactContext = reactContext
-        prefsHelper = SharedPreferencesLibraryUtil(mReactContext)
-        val viewModelStore = ViewModelStore()
-        val factory =
-            ViewModelProvider.AndroidViewModelFactory.getInstance(reactContext.applicationContext as Application)
-        mModel = ViewModelProvider(viewModelStore, factory)[MainActivityModel::class.java]
-        authenticateSDKService = AuthenticateSDKService(scope = scope)
+  ReactContextBaseJavaModule(reactContext) {
+  private val mModel: MainActivityModel
+  var authenticateSDKService: AuthenticateSDKService
+  private val job = Job()
+  private val scope = CoroutineScope(Dispatchers.IO + job)
+  var prefsHelper: SharedPreferencesLibraryUtil
+  private val apiScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+  private var debounceJob: Job? = null
+  private var lastDeviceStatus: PocDevice? = null
+
+  private var glucoseObserver: Observer<PocGlucose?>? = null
+  private var isObserving = false
+
+  init {
+    mReactContext = reactContext
+    prefsHelper = SharedPreferencesLibraryUtil(mReactContext)
+    val viewModelStore = ViewModelStore()
+    val factory =
+      ViewModelProvider.AndroidViewModelFactory.getInstance(reactContext.applicationContext as Application)
+    mModel = ViewModelProvider(viewModelStore, factory)[MainActivityModel::class.java]
+    authenticateSDKService = AuthenticateSDKService(scope = scope)
+  }
+
+
+  companion object {
+    var mReactContext: ReactApplicationContext? = null
+    var userToken: String = ""
+  }
+
+  override fun getName(): String {
+    return "CgmTrackyLib"
+  }
+
+  @ReactMethod
+  fun observeDeviceStatus(token: String) {
+    try {
+      userToken = token
+      Handler(Looper.getMainLooper()).post {
+        mModel.device.observeForever { device ->
+          if (device != lastDeviceStatus) {
+            lastDeviceStatus = device
+            postEventDataToAPI(device, "", lastDeviceStatus?.qrMessage ?: "")
+            resetDebounceTimer()
+          }
+
+          if (device != null) {
+            Log.d("observeDeviceStatus: ", device.toString())
+          }
+        }
+      }
+    } catch (e: Exception) {
+      Log.e("observeDeviceStatus", "observeDeviceStatus: ${e.message}")
     }
+  }
 
+  @ReactMethod
+  fun observeTransmitterUnbindStatus(token: String) {
+    try {
+      userToken = token
 
-    companion object {
-        var mReactContext: ReactApplicationContext? = null
-        var userToken: String = ""
-    }
+      authenticateSDKService.getCGMData(
+        environment = if ("uat".uppercase() == "PROD") TATVA_ENVIRONMENT.PROD else TATVA_ENVIRONMENT.STAGE,
+        token = userToken,
+        responseListener = object : AuthenticateSDKService.ResponseListener {
+          override fun onResponseSuccess(response: String) {
 
-    override fun getName(): String {
-        return "CgmTrackyLib"
-    }
+            val response = Gson().fromJson(response, CgmSensorResponse::class.java)
+            val sensor = response.data?.firstOrNull()
 
-    @ReactMethod
-    fun observeDeviceStatus(token: String) {
-        try {
-            userToken = token
-            Handler(Looper.getMainLooper()).post {
-                mModel.device.observeForever { device ->
-                    if (device != lastDeviceStatus) {
-                        lastDeviceStatus = device
-                        postEventDataToAPI(device, "", lastDeviceStatus?.qrMessage ?: "")
-                        resetDebounceTimer()
-                    }
-
-                    if (device != null) {
-                        Log.d("observeDeviceStatus: ", device.toString())
-                    }
-                }
-            }
-        } catch (e: Exception) {
-            Log.e("observeDeviceStatus", "observeDeviceStatus: ${e.message}")
-        }
-    }
+            if (sensor != null && !sensor.startDate.isNullOrEmpty() && !sensor.endDate.isNullOrEmpty()) {
+              val startDate = sensor.startDate
+              val endDate = sensor.endDate
+              val sensorId = sensor.sensorId
 
-    @ReactMethod
-    fun observeTransmitterUnbindStatus(token: String) {
-        try {
-            userToken = token
-
-            authenticateSDKService.getCGMData(
-                environment = if ("uat".uppercase() == "PROD") TATVA_ENVIRONMENT.PROD else TATVA_ENVIRONMENT.STAGE,
-                token = userToken,
-                responseListener = object : AuthenticateSDKService.ResponseListener {
-                    override fun onResponseSuccess(response: String) {
-
-                        val response = Gson().fromJson(response, CgmSensorResponse::class.java)
-                        val sensor = response.data?.firstOrNull()
-
-                        if (sensor != null && !sensor.startDate.isNullOrEmpty() && !sensor.endDate.isNullOrEmpty()) {
-                            val startDate = sensor.startDate
-                            val endDate = sensor.endDate
-                            val sensorId = sensor.sensorId
-
-                            println("Start Date: $startDate")
-                            println("End Date: $endDate")
-
-                            if (isCurrentDateInRange(startDate, endDate)) {
-
-                                println("Current date is in range")
-
-                                val pocDevice =
-                                    RepositoryDevice.getInstance(BApplication.getContext()).latestDeviceIoThread
-
-                                if (pocDevice != null) {
-                                    Log.d("pocDevice logsss", pocDevice.toString())
-
-                                    if (pocDevice.isUnBind) {
-                                        postEventDataToAPI(
-                                            pocDevice,
-                                            DeviceStatus.TRANSMITTER_DISCONNECT.id,
-                                            pocDevice.qrMessage
-                                        )
-                                    }
-                                } else {
-                                    Log.d("pocDevice logsss", "Data null")
-
-                                    postEventDataToAPI(
-                                        pocDevice,
-                                        DeviceStatus.TRANSMITTER_DISCONNECT.id,
-                                        sensorId
-                                    )
-                                }
-
-                            } else {
-                                println("Current date is out of range")
-                            }
-                        } else {
-                            println("Start or End date not available")
-                        }
-                    }
-
-                    override fun onResponseFail() {
-                    }
-                }
-            )
+              println("Start Date: $startDate")
+              println("End Date: $endDate")
 
-        } catch (e: Exception) {
-            Log.e("observeTransmitterUnbindStatus", "observeTransmitterUnbindStatus: ${e.message}")
-        }
-    }
+              if (isCurrentDateInRange(startDate, endDate)) {
 
-    private fun postEventDataToAPI(device: PocDevice?, mStatus: String, sensorId: String?) {
-        apiScope.launch {
-            try {
-                val bluetoothAdapter: BluetoothAdapter? = BluetoothAdapter.getDefaultAdapter()
-                val bleStatus = bluetoothAdapter?.isEnabled == true
-                var status = ""
-
-                status = if (mStatus.isEmpty()) {
-                    when {
-                        device?.isBoundAndConnect == true -> DeviceStatus.CONNECTED.id
-                        !bleStatus -> DeviceStatus.BLUETOOTH_OFF.id
-                        device?.isUnBind == true -> DeviceStatus.TRANSMITTER_DISCONNECT.id
-                        device?.isBoundButDisConnect == true -> DeviceStatus.DISCONNECTED.id
-                        else -> "" // fallback if no status matches
-                    }
-                } else {
-                    mStatus
-                }
+                println("Current date is in range")
+
+                val pocDevice =
+                  RepositoryDevice.getInstance(BApplication.getContext()).latestDeviceIoThread
 
-                if (status.isNotEmpty()) {
-                    val rawData = JSONObject().apply {
-                        put("transmitterName", device?.name ?: "")
-                        put("SensorId", sensorId ?: "")
-                        put("Sensor", sensorId ?: "")
-                        put("timeInMillis", Date().time)
-                    }
-
-                    val obj = JSONObject().apply {
-                        put("sensorId", sensorId ?: "")
-                        put("status", status)
-                        put("rawData", rawData)
-                    }
-
-                    authenticateSDKService.postDeviceData(
-                        environment = if ("uat".uppercase() == "PROD") TATVA_ENVIRONMENT.PROD else TATVA_ENVIRONMENT.STAGE,
-                        data = obj.toString(),
-                        token = userToken,
-                        loaderListener = object : LoaderListener {
-                            override fun onShowLoader() {}
-                            override fun onHideLoader() {}
-                        }
+                if (pocDevice != null) {
+                  Log.d("pocDevice logsss", pocDevice.toString())
+
+                  if (pocDevice.isUnBind) {
+                    postEventDataToAPI(
+                      pocDevice,
+                      DeviceStatus.TRANSMITTER_DISCONNECT.id,
+                      pocDevice.qrMessage
                     )
+                  }
+                } else {
+                  Log.d("pocDevice logsss", "Data null")
+
+                  postEventDataToAPI(
+                    pocDevice,
+                    DeviceStatus.TRANSMITTER_DISCONNECT.id,
+                    sensorId
+                  )
                 }
 
-            } catch (e: Exception) {
-                e.printStackTrace()
+              } else {
+                println("Current date is out of range")
+              }
+            } else {
+              println("Start or End date not available")
             }
-        }
-    }
+          }
 
-    private fun resetDebounceTimer() {
-        debounceJob?.cancel() // Cancel any existing timer
-        debounceJob = apiScope.launch {
-            delay(60 * 60 * 1000L) // 60 minutes in ms
-            lastDeviceStatus = null // Reset status after timeout
-            println("60 min window expired, status reset.")
+          override fun onResponseFail() {
+          }
         }
-    }
+      )
 
-    @ReactMethod
-    fun startCgmTracky(token: String) {
-        try {
-            userToken = token
-            val intent = Intent(currentActivity, StartCGMActivity::class.java)
-            currentActivity?.startActivity(intent)
-        } catch (e: Exception) {
-            Log.e("startCgmTracky", "startCgmTracky: ${e.message}")
-        }
+    } catch (e: Exception) {
+      Log.e("observeTransmitterUnbindStatus", "observeTransmitterUnbindStatus: ${e.message}")
     }
+  }
 
-    fun isCurrentDateInRange(startDateStr: String, endDateStr: String): Boolean {
-        val format = SimpleDateFormat("yyyy-MM-dd", Locale.getDefault())
+  private fun postEventDataToAPI(device: PocDevice?, mStatus: String, sensorId: String?) {
+    apiScope.launch {
+      try {
+        val bluetoothAdapter: BluetoothAdapter? = BluetoothAdapter.getDefaultAdapter()
+        val bleStatus = bluetoothAdapter?.isEnabled == true
+        var status = ""
+
+        status = if (mStatus.isEmpty()) {
+          when {
+            device?.isBoundAndConnect == true -> DeviceStatus.CONNECTED.id
+            !bleStatus -> DeviceStatus.BLUETOOTH_OFF.id
+            device?.isUnBind == true -> DeviceStatus.TRANSMITTER_DISCONNECT.id
+            device?.isBoundButDisConnect == true -> DeviceStatus.DISCONNECTED.id
+            else -> "" // fallback if no status matches
+          }
+        } else {
+          mStatus
+        }
 
-        val startDate = format.parse(startDateStr)
-        val endDate = format.parse(endDateStr)
-        val currentDate = Date()
+        if (status.isNotEmpty()) {
+          val rawData = JSONObject().apply {
+            put("transmitterName", device?.name ?: "")
+            put("SensorId", sensorId ?: "")
+            put("Sensor", sensorId ?: "")
+            put("timeInMillis", Date().time)
+          }
 
-        return startDate != null && endDate != null &&
-                !currentDate.before(startDate) && !currentDate.after(endDate)
-    }
+          val obj = JSONObject().apply {
+            put("sensorId", sensorId ?: "")
+            put("status", status)
+            put("rawData", rawData)
+          }
 
-    @ReactMethod
-    fun reconnectCgmTracky(token: String) {
-        try {
-            userToken = token
-            val intent = if (areAllPermissionsGranted()) {
-                Intent(currentActivity, SearchTransmitterActivity::class.java).putExtra(
-                    "IsForReconnect",
-                    true
-                )
-            } else {
-                Intent(currentActivity, PermissionActivity::class.java).putExtra(
-                    "IsForReconnect",
-                    true
-                )
+          authenticateSDKService.postDeviceData(
+            environment = if ("uat".uppercase() == "PROD") TATVA_ENVIRONMENT.PROD else TATVA_ENVIRONMENT.STAGE,
+            data = obj.toString(),
+            token = userToken,
+            loaderListener = object : LoaderListener {
+              override fun onShowLoader() {}
+              override fun onHideLoader() {}
             }
-            currentActivity?.startActivity(intent)
-        } catch (e: Exception) {
-            Log.e("reconnectCgmTracky", "reconnectCgmTracky: ${e.message}")
+          )
         }
-    }
 
-    @ReactMethod
-    fun openHelpSupport() {
-        try {
-            val intent = Intent(currentActivity, HelpActivity::class.java)
-            currentActivity?.startActivity(intent)
-        } catch (e: Exception) {
-            Log.e("openHelpSupport", "openHelpSupport: ${e.message}")
-        }
+      } catch (e: Exception) {
+        e.printStackTrace()
+      }
+    }
+  }
+
+  private fun resetDebounceTimer() {
+    debounceJob?.cancel() // Cancel any existing timer
+    debounceJob = apiScope.launch {
+      delay(60 * 60 * 1000L) // 60 minutes in ms
+      lastDeviceStatus = null // Reset status after timeout
+      println("60 min window expired, status reset.")
     }
+  }
 
-    private fun areAllPermissionsGranted(): Boolean {
-        val requiredPermissions = mutableListOf<String>()
+  @ReactMethod
+  fun startCgmTracky(token: String) {
+    try {
+      userToken = token
+      val intent = Intent(currentActivity, StartCGMActivity::class.java)
+      currentActivity?.startActivity(intent)
+    } catch (e: Exception) {
+      Log.e("startCgmTracky", "startCgmTracky: ${e.message}")
+    }
+  }
 
-        // Add Bluetooth permissions
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-            requiredPermissions.addAll(PermissionUtils.BLUETOOTH_S)
-        }
+  fun isCurrentDateInRange(startDateStr: String, endDateStr: String): Boolean {
+    val format = SimpleDateFormat("yyyy-MM-dd", Locale.getDefault())
 
-        // Add location permissions
-        requiredPermissions.addAll(PermissionUtils.LOCAL_PERMISSION)
+    val startDate = format.parse(startDateStr)
+    val endDate = format.parse(endDateStr)
+    val currentDate = Date()
 
-        // Add camera permission
-        requiredPermissions.addAll(PermissionUtils.CAMERA_PERMISSION)
+    return startDate != null && endDate != null &&
+      !currentDate.before(startDate) && !currentDate.after(endDate)
+  }
 
-        return requiredPermissions.all {
-            ContextCompat.checkSelfPermission(
-                mReactContext!!,
-                it
-            ) == PackageManager.PERMISSION_GRANTED
-        }
+  @ReactMethod
+  fun reconnectCgmTracky(token: String) {
+    try {
+      userToken = token
+      val intent = if (areAllPermissionsGranted()) {
+        Intent(currentActivity, SearchTransmitterActivity::class.java).putExtra(
+          "IsForReconnect",
+          true
+        )
+      } else {
+        Intent(currentActivity, PermissionActivity::class.java).putExtra(
+          "IsForReconnect",
+          true
+        )
+      }
+      currentActivity?.startActivity(intent)
+    } catch (e: Exception) {
+      Log.e("reconnectCgmTracky", "reconnectCgmTracky: ${e.message}")
     }
+  }
+
+  @ReactMethod
+  fun openHelpSupport() {
+    try {
+      val intent = Intent(currentActivity, HelpActivity::class.java)
+      currentActivity?.startActivity(intent)
+    } catch (e: Exception) {
+      Log.e("openHelpSupport", "openHelpSupport: ${e.message}")
+    }
+  }
 
+  private fun areAllPermissionsGranted(): Boolean {
+    val requiredPermissions = mutableListOf<String>()
 
-    /*@ReactMethod
-    fun observeGlucoseData(token: String) {
-      try {
-        userToken = token
-        Handler(Looper.getMainLooper()).post {
-          //Observe latest glucose data
-          mModel.latestGlucose.observeForever { pocGlucose ->
-            if (pocGlucose != null) {
-
-              if (pocGlucose.errorCode == enumError.NONE) {
-                if (pocGlucose.showGlucoseMG > 0) {
-                  val dto: GlucoseLog = mapToDto(pocGlucose)
-                  val logs: ArrayList<GlucoseLog> = ArrayList()
-                  logs.add(dto)
-
-                  val request: GlucoseLogRequest =
-                    GlucoseLogRequest(vendor = "GoodFlip", logs = logs)
-                  val gson: Gson = GsonBuilder().create()
-                  val json = gson.toJson(request)
-
-                  Log.d("Glucose data 3 min==> ", "Glucose data 3 min==> final Json: $json")
-
-                  authenticateSDKService.postCGMData(
-                    environment = if ("uat".uppercase() == "PROD") TATVA_ENVIRONMENT.PROD else TATVA_ENVIRONMENT.STAGE,
-                    data = json.toString(),
-                    token = userToken,
-                    responseListener = object :
-                      AuthenticateSDKService.ResponseListener {
-                      override fun onResponseSuccess() {
-                      }
-
-                      override fun onResponseFail() {
-                      }
-                    }
-                  )
-                }
-              } else {
-                if (pocGlucose.errorCode == enumError.ERROR_FLOODING_WATER) {
-                  lastDeviceStatus =
-                    pocGlucose.deviceId.toInt().let { mModel.getDeviceInfo(it) }
-                  lastDeviceStatus?.let {
-                    postEventDataToAPI(
-                      it,
-                      DeviceStatus.MOISTURE_DETECT.id
-                    )
-                  }
-                  resetDebounceTimer()
-                } else if (pocGlucose.errorCode == enumError.ERROR_CURRENT_SMALL || pocGlucose.errorCode == enumError.ERROR_NOISE || pocGlucose.errorCode == enumError.ERROR_SENSITIVITY_ATTENUATION) {
-                  lastDeviceStatus =
-                    pocGlucose.deviceId.toInt().let { mModel.getDeviceInfo(it) }
-                  lastDeviceStatus?.let {
-                    postEventDataToAPI(
-                      it,
-                      DeviceStatus.WEAK_SIGNAL.id
-                    )
-                  }
-                  resetDebounceTimer()
-                } else {
-                  lastDeviceStatus =
-                    pocGlucose.deviceId.toInt().let { mModel.getDeviceInfo(it) }
-                  lastDeviceStatus?.let {
-                    postEventDataToAPI(
-                      it,
-                      DeviceStatus.ERROR_COMMON.id
-                    )
-                  }
-                  resetDebounceTimer()
-                }
-              }
-            }
-          }
-        }
-      } catch (e: Exception) {
-        Log.e("observeGlucoseData", "observeGlucoseData: ${e.message}")
-      }
-    }*/
-
-    @ReactMethod
-    fun observeGlucoseData(token: String) {
-        try {
-            userToken = token
+    // Add Bluetooth permissions
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+      requiredPermissions.addAll(PermissionUtils.BLUETOOTH_S)
+    }
 
-            // Remove existing observer if any to prevent memory leaks
-            stopObservingGlucoseData()
+    // Add location permissions
+    requiredPermissions.addAll(PermissionUtils.LOCAL_PERMISSION)
 
-            // Create new observer with explicit nullable parameter type
-            glucoseObserver = Observer<PocGlucose?> { pocGlucose ->
-                // Critical fix: Explicitly handle nullable parameter
-                if (pocGlucose != null) {
-                    handleGlucoseData(pocGlucose)
-                } else {
-                    Log.w("observeGlucoseData", "Received null glucose data - skipping processing")
-                }
-            }
+    // Add camera permission
+    requiredPermissions.addAll(PermissionUtils.CAMERA_PERMISSION)
 
-            // Add observer on main thread
-            Handler(Looper.getMainLooper()).post {
-                glucoseObserver?.let { observer ->
-                    try {
-                        mModel.latestGlucose.observeForever(observer)
-                        isObserving = true
-                        Log.d("observeGlucoseData", "Observer added successfully")
-                    } catch (e: Exception) {
-                        Log.e("observeGlucoseData", "Error adding observer: ${e.message}")
-                        glucoseObserver = null
-                    }
-                }
-            }
-        } catch (e: Exception) {
-            Log.e("observeGlucoseData", "observeGlucoseData: ${e.message}")
-            e.printStackTrace()
-        }
+    return requiredPermissions.all {
+      ContextCompat.checkSelfPermission(
+        mReactContext!!,
+        it
+      ) == PackageManager.PERMISSION_GRANTED
     }
+  }
 
+  @ReactMethod
+  fun observeGlucoseData(token: String) {
+    try {
+      userToken = token
 
-    private fun handleGlucoseData(pocGlucose: PocGlucose) {
-        try {
-            // Additional safety check
-            if (pocGlucose.glucoseId == null) {
-                Log.w("handleGlucoseData", "Glucose ID is null, skipping processing")
-                return
-            }
+      // Remove existing observer if any to prevent memory leaks
+      stopObservingGlucoseData()
+
+      // Create new observer with explicit nullable parameter type
+      glucoseObserver = Observer<PocGlucose?> { pocGlucose ->
+        if (pocGlucose != null) {
+          // Add timestamp check to prevent processing old data
+          val currentTime = System.currentTimeMillis()
+          val dataAge = currentTime - pocGlucose.timeInMillis
+
+          // Only process data that's relatively recent (within last 10 minutes as example)
+          // Adjust this threshold based on your requirements
+          if (dataAge <= 10 * 60 * 1000L) { // 10 minutes
+            handleGlucoseData(pocGlucose)
+          } else {
+            Log.d("observeGlucoseData", "Skipping old glucose data: age = ${dataAge}ms")
+          }
+        } else {
+          Log.w("observeGlucoseData", "Received null glucose data - skipping processing")
+        }
+      }
 
-            Log.d("handleGlucoseData", "Processing glucose data: ${pocGlucose.glucoseId}")
-
-            if (pocGlucose.errorCode == enumError.NONE) {
-                if (pocGlucose.showGlucoseMG > 0) {
-                    val dto: GlucoseLog = mapToDto(pocGlucose)
-                    val logs: ArrayList<GlucoseLog> = ArrayList()
-                    logs.add(dto)
-
-                    val request: GlucoseLogRequest =
-                        GlucoseLogRequest(vendor = "GoodFlip", logs = logs)
-                    val gson: Gson = GsonBuilder().create()
-                    val json = gson.toJson(request)
-
-                    Log.d("Glucose data 3 min==> ", "Glucose data 3 min==> final Json: $json")
-
-                    authenticateSDKService.postCGMData(
-                        environment = if ("uat".uppercase() == "PROD") TATVA_ENVIRONMENT.PROD else TATVA_ENVIRONMENT.STAGE,
-                        data = json,
-                        token = userToken,
-                        responseListener = object : AuthenticateSDKService.ResponseListener {
-                            override fun onResponseSuccess(response: String) {
-                                updateSyncMetadata(pocGlucose)
-                                Log.d("CGM Data", "Single glucose data uploaded successfully")
-                            }
-
-                            override fun onResponseFail() {
-                                Log.e("CGM Data", "Failed to upload single glucose data")
-                            }
-                        }
-                    )
-                } else {
-                    Log.d(
-                        "handleGlucoseData",
-                        "Glucose value is 0 or negative: ${pocGlucose.showGlucoseMG}"
-                    )
-                }
-            } else {
-                Log.d("handleGlucoseData", "Glucose data has error: ${pocGlucose.errorCode}")
-                handleGlucoseError(pocGlucose)
-            }
-        } catch (e: Exception) {
-            Log.e("handleGlucoseData", "Error handling glucose data: ${e.message}")
-            e.printStackTrace()
+      // Add observer on main thread
+      Handler(Looper.getMainLooper()).post {
+        glucoseObserver?.let { observer ->
+          try {
+            mModel.latestGlucose.observeForever(observer)
+            isObserving = true
+            Log.d("observeGlucoseData", "Live glucose observer started successfully")
+          } catch (e: Exception) {
+            Log.e("observeGlucoseData", "Error adding observer: ${e.message}")
+            glucoseObserver = null
+          }
         }
+      }
+    } catch (e: Exception) {
+      Log.e("observeGlucoseData", "observeGlucoseData: ${e.message}")
+      e.printStackTrace()
     }
+  }
+
+  private fun handleGlucoseData(pocGlucose: PocGlucose) {
+    try {
+      // Additional safety check
+      if (pocGlucose.glucoseId == null) {
+        Log.w("handleGlucoseData", "Glucose ID is null, skipping processing")
+        return
+      }
 
-    // Extract error handling logic
-    private fun handleGlucoseError(pocGlucose: PocGlucose) {
-        try {
-            // Additional safety check for deviceId
-            if (pocGlucose.deviceId == null) {
-                Log.e("handleGlucoseError", "Device ID is null, cannot process error")
-                return
-            }
-
-            val deviceInfo = mModel.getDeviceInfo(pocGlucose.deviceId.toInt())
-            deviceInfo?.let {
-                val statusId = when (pocGlucose.errorCode) {
-                    enumError.ERROR_FLOODING_WATER -> {
-                        Log.d("handleGlucoseError", "Moisture detected")
-                        DeviceStatus.MOISTURE_DETECT.id
-                    }
-
-                    enumError.ERROR_CURRENT_SMALL,
-                    enumError.ERROR_NOISE,
-                    enumError.ERROR_SENSITIVITY_ATTENUATION -> {
-                        Log.d("handleGlucoseError", "Weak signal detected")
-                        DeviceStatus.WEAK_SIGNAL.id
-                    }
-
-                    else -> {
-                        Log.d(
-                            "handleGlucoseError",
-                            "Common error detected: ${pocGlucose.errorCode}"
-                        )
-                        DeviceStatus.ERROR_COMMON.id
-                    }
-                }
+      Log.d("handleGlucoseData", "Processing glucose data: ${pocGlucose.glucoseId}")
+
+      if (pocGlucose.errorCode == enumError.NONE) {
+        if (pocGlucose.showGlucoseMG > 0) {
+          val dto: GlucoseLog = mapToDto(pocGlucose)
+          val logs: ArrayList<GlucoseLog> = ArrayList()
+          logs.add(dto)
+
+          val request: GlucoseLogRequest =
+            GlucoseLogRequest(vendor = "GoodFlip", logs = logs)
+          val gson: Gson = GsonBuilder().create()
+          val json = gson.toJson(request)
+
+          Log.d("Glucose data 3 min==> ", "Glucose data 3 min==> final Json: $json")
+
+          authenticateSDKService.postCGMData(
+            environment = if ("uat".uppercase() == "PROD") TATVA_ENVIRONMENT.PROD else TATVA_ENVIRONMENT.STAGE,
+            data = json,
+            token = userToken,
+            responseListener = object : AuthenticateSDKService.ResponseListener {
+              override fun onResponseSuccess(response: String) {
+                updateSyncMetadata(pocGlucose)
+                Log.d("CGM Data", "Single glucose data uploaded successfully")
+              }
 
-                postEventDataToAPI(it, statusId, it.qrMessage)
-                resetDebounceTimer()
-            } ?: run {
-                Log.e(
-                    "handleGlucoseError",
-                    "Device info not found for deviceId: ${pocGlucose.deviceId}"
-                )
+              override fun onResponseFail() {
+                Log.e("CGM Data", "Failed to upload single glucose data")
+              }
             }
-        } catch (e: Exception) {
-            Log.e("handleGlucoseError", "Error handling glucose error: ${e.message}")
-            e.printStackTrace()
+          )
+        } else {
+          Log.d(
+            "handleGlucoseData",
+            "Glucose value is 0 or negative: ${pocGlucose.showGlucoseMG}"
+          )
         }
+      } else {
+        Log.d("handleGlucoseData", "Glucose data has error: ${pocGlucose.errorCode}")
+        handleGlucoseError(pocGlucose)
+      }
+    } catch (e: Exception) {
+      Log.e("handleGlucoseData", "Error handling glucose data: ${e.message}")
+      e.printStackTrace()
     }
+  }
+
+  // Extract error handling logic
+  private fun handleGlucoseError(pocGlucose: PocGlucose) {
+    try {
+      // Additional safety check for deviceId
+      if (pocGlucose.deviceId == null) {
+        Log.e("handleGlucoseError", "Device ID is null, cannot process error")
+        return
+      }
 
-    /*@ReactMethod
-    fun observeAllGlucoseData(token: String) {
-      userToken = token
-      Log.e("userToken", "userToken: ${userToken}")
-      try {
-        val lastSyncData = prefsHelper.lastSyncData
-        Log.d("lastSyncData: ", Gson().toJson(lastSyncData).toString())
-
-        if (lastSyncData != null) {
-          CoroutineScope(Dispatchers.IO).launch {
-            getGlucoseDataAndUploadInBatch(
-              mModel.getGlucoseBetweenTime(
-                lastSyncData.lastSyncTime
-              )
+      val deviceInfo = mModel.getDeviceInfo(pocGlucose.deviceId.toInt())
+      deviceInfo?.let {
+        val statusId = when (pocGlucose.errorCode) {
+          enumError.ERROR_FLOODING_WATER -> {
+            Log.d("handleGlucoseError", "Moisture detected")
+            DeviceStatus.MOISTURE_DETECT.id
+          }
+
+          enumError.ERROR_CURRENT_SMALL,
+          enumError.ERROR_NOISE,
+          enumError.ERROR_SENSITIVITY_ATTENUATION -> {
+            Log.d("handleGlucoseError", "Weak signal detected")
+            DeviceStatus.WEAK_SIGNAL.id
+          }
+
+          else -> {
+            Log.d(
+              "handleGlucoseError",
+              "Common error detected: ${pocGlucose.errorCode}"
             )
+            DeviceStatus.ERROR_COMMON.id
           }
-        } else {
-          observeGlucoseData(userToken)
         }
 
-      } catch (e: Exception) {
-        Log.e("observeAllGlucoseData", "observeAllGlucoseData Error: ${e.message}")
+        postEventDataToAPI(it, statusId, it.qrMessage)
+        resetDebounceTimer()
+      } ?: run {
+        Log.e(
+          "handleGlucoseError",
+          "Device info not found for deviceId: ${pocGlucose.deviceId}"
+        )
       }
-    }*/
-
-
-    @ReactMethod
-    fun observeAllGlucoseData(token: String) {
-        userToken = token
-        Log.e("userToken", "userToken: $token")
-
-        // Stop current observation to prevent duplicates
-        stopObservingGlucoseData()
-
-        try {
-            val lastSyncData = prefsHelper.lastSyncData
-            Log.d("lastSyncData: ", Gson().toJson(lastSyncData).toString())
-
-            if (lastSyncData != null) {
-                CoroutineScope(Dispatchers.IO).launch {
-                    val glucoseData = mModel.getGlucoseBetweenTime(lastSyncData.lastSyncTime)
-                    if (glucoseData != null) {
-                        getGlucoseDataAndUploadInBatch(glucoseData)
-                    } else {
-                        Log.d(
-                            "observeAllGlucoseData",
-                            "No glucose data found, starting live observation"
-                        )
-                        observeGlucoseData(userToken)
-                    }
-                }
-            } else {
-                observeGlucoseData(userToken)
-            }
-        } catch (e: Exception) {
-            Log.e("observeAllGlucoseData", "observeAllGlucoseData Error: ${e.message}")
-        }
+    } catch (e: Exception) {
+      Log.e("handleGlucoseError", "Error handling glucose error: ${e.message}")
+      e.printStackTrace()
     }
+  }
 
-    @ReactMethod
-    fun stopObservingGlucoseData() {
-        try {
-            glucoseObserver?.let { observer ->
-                Handler(Looper.getMainLooper()).post {
-                    try {
-                        mModel.latestGlucose.removeObserver(observer)
-                        isObserving = false
-                        Log.d("stopObservingGlucoseData", "Observer removed successfully")
-                    } catch (e: Exception) {
-                        Log.e("stopObservingGlucoseData", "Error removing observer: ${e.message}")
-                    }
-                }
-            }
-            glucoseObserver = null
-        } catch (e: Exception) {
-            Log.e("stopObservingGlucoseData", "Error stopping observer: ${e.message}")
-        }
-    }
 
-    fun getGlucoseDataAndUploadInBatch(dataList: List<PocGlucose>) {
-        if (dataList.isEmpty()) {
-            Log.d("getGlucoseDataAndUploadInBatch", "No data to upload, starting live observation")
-            if (!isObserving) {
-                observeGlucoseData(userToken)
-            }
-            return
-        }
+  @ReactMethod
+  fun observeAllGlucoseData(token: String) {
+    userToken = token
 
-        val batchSize = 40
-        val chunks = dataList.chunked(batchSize)
+    // Stop current observation to prevent duplicates
+    stopObservingGlucoseData()
 
-        Log.d("getGlucoseDataAndUploadInBatch", "Starting batch upload with ${chunks.size} batches")
+    try {
+      val lastSyncData = prefsHelper.lastSyncData
+      Log.d("lastSyncData: ", Gson().toJson(lastSyncData).toString())
 
+      if (lastSyncData != null) {
         CoroutineScope(Dispatchers.IO).launch {
-            var lastSyncedRecord: PocGlucose? = null
-            var allBatchesSuccessful = true
-
-            for ((index, batch) in chunks.withIndex()) {
-                try {
-                    val transformedLogs = batch.filter { it.showGlucoseMG > 0 }.map { pocGlucose ->
-                        CgmLog(
-                            timeInMillis = pocGlucose.timeInMillis,
-                            countdownMinutes = pocGlucose.countdownMinutes,
-                            countdownDays = pocGlucose.countdownDays,
-                            hypoglycemiaEarlyWarnMinutes = pocGlucose.hypoglycemiaEarlyWarnMinutes,
-                            showGlucoseMG = pocGlucose.showGlucoseMG,
-                            glucoseId = pocGlucose.glucoseId,
-                            name = pocGlucose.name,
-                            bytes = pocGlucose.bytes,
-                            showGlucose = pocGlucose.showGlucose,
-                            Ib = pocGlucose.ib,
-                            Iw = pocGlucose.iw,
-                            countdownHours = pocGlucose.countdownHours,
-                            T = pocGlucose.t,
-                            year = pocGlucose.year,
-                            month = pocGlucose.month,
-                            day = pocGlucose.day,
-                            hour = pocGlucose.hour,
-                            minute = pocGlucose.minute,
-                            trendObject = com.mytatvarnsdk.model.TrendObject(
-                                trendId = pocGlucose.trend.trendId,
-                                drawableId = pocGlucose.trend.drawableId,
-                                widgetImg = pocGlucose.trend.widgetImg,
-                                apsChangeRate = pocGlucose.trend.apsChangeRate
-                            ),
-                            glucoseStatusObject = com.mytatvarnsdk.model.GlucoseStatusObject(
-                                statusId = pocGlucose.glucoseStatus.statusId
-                            ),
-                            errorObject = com.mytatvarnsdk.model.ErrorObject(
-                                errorId = pocGlucose.errorCode.errorId,
-                                sound = pocGlucose.errorCode.sound
-                            )
-                        )
-                    }
-
-                    if (transformedLogs.isEmpty()) {
-                        Log.d("Batch Upload", "Batch $index skipped - no valid glucose readings")
-                        continue
-                    }
-
-                    val allResult = AllCGMLogRequest(vendor = "GoodFlip", logs = transformedLogs)
-                    val json = Gson().toJson(allResult)
-
-                    Log.d("Batch Upload JSON", "Batch $index with ${transformedLogs.size} records")
-                    logLongJson("Batch $index JSON=>>> ", json)
-
-                    val uploadSuccessful = uploadBatchSynchronously(json, index)
-
-                    if (uploadSuccessful) {
-                        lastSyncedRecord = batch.lastOrNull()
-                        updateSyncMetadata(lastSyncedRecord)
-                        Log.d("Batch Upload", "✅ Batch $index uploaded successfully")
-                    } else {
-                        allBatchesSuccessful = false
-                        Log.e("Batch Upload", "❌ Batch $index failed, stopping further uploads")
-                        break
-                    }
-
-                    delay(500L) // Rate limiting between batches
-
-                } catch (e: Exception) {
-                    Log.e("Batch Upload", "❌ Batch $index exception: ${e.message}")
-                    allBatchesSuccessful = false
-                    break
-                }
-            }
-
-            // Handle last synced record error status
-            lastSyncedRecord?.let { record ->
-                if (record.errorCode != enumError.NONE) {
-                    handleGlucoseError(record)
-                }
+          val glucoseData = mModel.getGlucoseBetweenTime(lastSyncData.lastSyncTime)
+          if (glucoseData != null && glucoseData.isNotEmpty()) {
+            // Process batch data and wait for completion
+            processBatchDataAndStartObserver(glucoseData)
+          } else {
+            Log.d("observeAllGlucoseData", "No historical data found, starting live observation")
+            // Start live observation immediately if no historical data
+            Handler(Looper.getMainLooper()).post {
+              observeGlucoseData(userToken)
             }
+          }
+        }
+      } else {
+        // No sync data exists, start live observation
+        observeGlucoseData(userToken)
+      }
+    } catch (e: Exception) {
+      Log.e("observeAllGlucoseData", "observeAllGlucoseData Error: ${e.message}")
+      // Fallback to live observation on error
+      observeGlucoseData(userToken)
+    }
+  }
+
+  // New method to handle batch processing and ensure proper sequencing
+  private suspend fun processBatchDataAndStartObserver(dataList: List<PocGlucose>) {
+    try {
+      // Process all batches
+      val success = processBatchDataSynchronously(dataList)
+
+      // Only start live observer after batch processing is completely done
+      if (success) {
+        Log.d(
+          "processBatchDataAndStartObserver",
+          "Batch processing completed successfully, starting live observer"
+        )
+      } else {
+        Log.w(
+          "processBatchDataAndStartObserver",
+          "Batch processing had failures, still starting live observer"
+        )
+      }
 
-            Log.d("Batch Upload", "Batch upload completed. Success: $allBatchesSuccessful")
+      // Start live observation on main thread after batch completion
+      Handler(Looper.getMainLooper()).post {
+        if (!isObserving) {
+          observeGlucoseData(userToken)
+        }
+      }
 
-            // Only start observing new data if we're not already doing so
-            if (!isObserving) {
-                observeGlucoseData(userToken)
-            }
+    } catch (e: Exception) {
+      Log.e("processBatchDataAndStartObserver", "Error in batch processing: ${e.message}")
+      // Start live observation even on error
+      Handler(Looper.getMainLooper()).post {
+        if (!isObserving) {
+          observeGlucoseData(userToken)
         }
+      }
     }
+  }
 
-    // Helper method for synchronous batch upload
-    private suspend fun uploadBatchSynchronously(json: String, batchIndex: Int): Boolean {
-        return suspendCoroutine { continuation ->
-            try {
-                authenticateSDKService.postCGMData(
-                    environment = if ("uat".uppercase() == "PROD") TATVA_ENVIRONMENT.PROD else TATVA_ENVIRONMENT.STAGE,
-                    data = json,
-                    token = userToken,
-                    responseListener = object : AuthenticateSDKService.ResponseListener {
-                        override fun onResponseSuccess(response: String) {
-                            continuation.resume(true)
-                        }
-
-                        override fun onResponseFail() {
-                            continuation.resume(false)
-                        }
-                    }
-                )
-            } catch (e: Exception) {
-                Log.e("uploadBatchSynchronously", "Exception in batch $batchIndex: ${e.message}")
-                continuation.resume(false)
-            }
-        }
+  // Updated batch processing method with better sync control
+  private suspend fun processBatchDataSynchronously(dataList: List<PocGlucose>): Boolean {
+    if (dataList.isEmpty()) {
+      Log.d("processBatchDataSynchronously", "No data to upload")
+      return true
     }
 
-    private fun updateSyncMetadata(lastRecord: PocGlucose?) {
-        lastRecord?.let {
-            try {
-                val syncData = SyncMeta(
-                    Date().time,
-                    it.timeInMillis,
-                    it.deviceId,
-                    it.glucoseId
-                )
-                prefsHelper.lastSyncData = syncData
-                Log.d("Sync Metadata", "Last sync data stored: ${Gson().toJson(syncData)}")
-            } catch (e: Exception) {
-                Log.e("updateSyncMetadata", "Error updating sync metadata: ${e.message}")
-            }
+    val batchSize = 40
+    val chunks = dataList.chunked(batchSize)
+    var lastSyncedRecord: PocGlucose? = null
+    var allBatchesSuccessful = true
+
+    Log.d("processBatchDataSynchronously", "Starting batch upload with ${chunks.size} batches")
+
+    for ((index, batch) in chunks.withIndex()) {
+      try {
+        val transformedLogs = batch.filter { it.showGlucoseMG > 0 }.map { pocGlucose ->
+          CgmLog(
+            timeInMillis = pocGlucose.timeInMillis,
+            countdownMinutes = pocGlucose.countdownMinutes,
+            countdownDays = pocGlucose.countdownDays,
+            hypoglycemiaEarlyWarnMinutes = pocGlucose.hypoglycemiaEarlyWarnMinutes,
+            showGlucoseMG = pocGlucose.showGlucoseMG,
+            glucoseId = pocGlucose.glucoseId,
+            name = pocGlucose.name,
+            bytes = pocGlucose.bytes,
+            showGlucose = pocGlucose.showGlucose,
+            Ib = pocGlucose.ib,
+            Iw = pocGlucose.iw,
+            countdownHours = pocGlucose.countdownHours,
+            T = pocGlucose.t,
+            year = pocGlucose.year,
+            month = pocGlucose.month,
+            day = pocGlucose.day,
+            hour = pocGlucose.hour,
+            minute = pocGlucose.minute,
+            trendObject = com.mytatvarnsdk.model.TrendObject(
+              trendId = pocGlucose.trend.trendId,
+              drawableId = pocGlucose.trend.drawableId,
+              widgetImg = pocGlucose.trend.widgetImg,
+              apsChangeRate = pocGlucose.trend.apsChangeRate
+            ),
+            glucoseStatusObject = com.mytatvarnsdk.model.GlucoseStatusObject(
+              statusId = pocGlucose.glucoseStatus.statusId
+            ),
+            errorObject = com.mytatvarnsdk.model.ErrorObject(
+              errorId = pocGlucose.errorCode.errorId,
+              sound = pocGlucose.errorCode.sound
+            )
+          )
         }
-    }
 
-    /*fun getGlucoseDataAndUploadInBatch(dataList: List<PocGlucose>) {
-      if (dataList.isNotEmpty()) {
-        val batchSize = 40
+        if (transformedLogs.isEmpty()) {
+          Log.d("processBatchDataSynchronously", "Batch $index skipped - no valid glucose readings")
+          continue
+        }
 
-        val chunks = dataList.chunked(batchSize)
+        val allResult = AllCGMLogRequest(vendor = "GoodFlip", logs = transformedLogs)
+        val json = Gson().toJson(allResult)
 
-        CoroutineScope(Dispatchers.IO).launch {
+        Log.d("Batch Upload", "Processing batch $index with ${transformedLogs.size} records")
+        logLongJson("Batch $index JSON=>>> ", json)
 
-          var lastSyncedRecord: PocGlucose? = null
-
-          for ((index, batch) in chunks.withIndex()) {
-            try {
-              val transformedLogs = batch.filter { it.showGlucoseMG > 0 }.map {
-                CgmLog(
-                  timeInMillis = it.timeInMillis,
-                  countdownMinutes = it.countdownMinutes,
-                  countdownDays = it.countdownDays,
-                  hypoglycemiaEarlyWarnMinutes = it.hypoglycemiaEarlyWarnMinutes,
-                  showGlucoseMG = it.showGlucoseMG,
-                  glucoseId = it.glucoseId,
-                  name = it.name,
-                  bytes = it.bytes,
-                  showGlucose = it.showGlucose,
-                  Ib = it.ib,
-                  Iw = it.iw,
-                  countdownHours = it.countdownHours,
-                  T = it.t,
-                  year = it.year,
-                  month = it.month,
-                  day = it.day,
-                  hour = it.hour,
-                  minute = it.minute,
-                  trendObject = com.mytatvarnsdk.model.TrendObject(
-                    trendId = it.trend.trendId,
-                    drawableId = it.trend.drawableId,
-                    widgetImg = it.trend.widgetImg,
-                    apsChangeRate = it.trend.apsChangeRate
-                  ),
-                  glucoseStatusObject = com.mytatvarnsdk.model.GlucoseStatusObject(
-                    statusId = it.glucoseStatus.statusId
-                  ),
-                  errorObject = com.mytatvarnsdk.model.ErrorObject(
-                    errorId = it.errorCode.errorId,
-                    sound = it.errorCode.sound
-                  )
-                )
-              }
+        val uploadSuccessful = uploadBatchSynchronously(json, index)
 
-              val allResult = AllCGMLogRequest(
-                vendor = "GoodFlip",
-                logs = transformedLogs
-              )
-
-              val json = Gson().toJson(allResult)
-              logLongJson("Final JSON=>>> ", json)
-
-  //            sendDataToReact(Gson().toJson(batch).toString(), "DATA_FETCH", "CGMData")
-
-              authenticateSDKService.postCGMData(
-                environment = if ("uat".uppercase() == "PROD") TATVA_ENVIRONMENT.PROD else TATVA_ENVIRONMENT.STAGE,
-                data = json.toString(),
-                token = userToken,
-                responseListener = object : AuthenticateSDKService.ResponseListener {
-                  override fun onResponseSuccess() {
-                    lastSyncedRecord = batch.lastOrNull()
-
-                    lastSyncedRecord?.let {
-                      val syncData =
-                        SyncMeta(
-                          Date().time,
-                          it.timeInMillis,
-                          it.deviceId,
-                          it.glucoseId
-                        )
-                      prefsHelper.lastSyncData = syncData
-                      Log.d(
-                        "lastSyncedRecord stored:--- ",
-                        Gson().toJson(syncData).toString()
-                      )
-                    }
-                  }
+        if (uploadSuccessful) {
+          lastSyncedRecord = batch.lastOrNull()
+          // Update sync metadata after each successful batch
+          updateSyncMetadata(lastSyncedRecord)
+          Log.d("Batch Upload", "✅ Batch $index uploaded and synced successfully")
+        } else {
+          allBatchesSuccessful = false
+          Log.e("Batch Upload", "❌ Batch $index failed")
+          // Continue with next batch instead of breaking (optional based on your needs)
+          // break
+        }
 
-                  override fun onResponseFail() {
-                    Log.e("Batch Upload", "❌ Batch $index failed")
-                  }
-                }
-              )
+        // Rate limiting between batches
+        delay(500L)
 
-              delay(500L)
-            } catch (e: Exception) {
-              Log.e("Batch Upload", "❌ Batch $index exception: ${e.message}")
-              break // Optional: stop further processing if exception occurs
-            }
-          }
+      } catch (e: Exception) {
+        Log.e("Batch Upload", "❌ Batch $index exception: ${e.message}")
+        allBatchesSuccessful = false
+        // Continue processing other batches
+      }
+    }
 
+    // Handle error status for the last processed record
+    lastSyncedRecord?.let { record ->
+      if (record.errorCode != enumError.NONE) {
+        handleGlucoseError(record)
+      }
+    }
 
-          if (lastSyncedRecord != null) {
-            if (lastSyncedRecord?.errorCode != enumError.NONE) {
-              if (lastSyncedRecord?.errorCode == enumError.ERROR_FLOODING_WATER) {
-                lastDeviceStatus =
-                  lastSyncedRecord?.deviceId!!.toInt().let { mModel.getDeviceInfo(it) }
-                lastDeviceStatus?.let {
-                  postEventDataToAPI(
-                    it,
-                    DeviceStatus.MOISTURE_DETECT.id
-                  )
-                }
-                resetDebounceTimer()
-              } else if (lastSyncedRecord?.errorCode == enumError.ERROR_CURRENT_SMALL || lastSyncedRecord?.errorCode == enumError.ERROR_NOISE || lastSyncedRecord?.errorCode == enumError.ERROR_SENSITIVITY_ATTENUATION) {
-                lastDeviceStatus =
-                  lastSyncedRecord?.deviceId!!.toInt().let { mModel.getDeviceInfo(it) }
-                lastDeviceStatus?.let {
-                  postEventDataToAPI(
-                    it,
-                    DeviceStatus.WEAK_SIGNAL.id
-                  )
-                }
-                resetDebounceTimer()
-              } else {
-                lastDeviceStatus =
-                  lastSyncedRecord?.deviceId!!.toInt().let { mModel.getDeviceInfo(it) }
-                lastDeviceStatus?.let {
-                  postEventDataToAPI(
-                    it,
-                    DeviceStatus.ERROR_COMMON.id
-                  )
-                }
-                resetDebounceTimer()
-              }
-            }
-          }
+    Log.d(
+      "processBatchDataSynchronously",
+      "Batch processing completed. Overall success: $allBatchesSuccessful"
+    )
+    return allBatchesSuccessful
+  }
 
-          Log.e("Batch Upload", "All data uploaded")
 
-          observeGlucoseData(userToken)
+  @ReactMethod
+  fun stopObservingGlucoseData() {
+    try {
+      glucoseObserver?.let { observer ->
+        Handler(Looper.getMainLooper()).post {
+          try {
+            mModel.latestGlucose.removeObserver(observer)
+            isObserving = false
+            Log.d("stopObservingGlucoseData", "Observer removed successfully")
+          } catch (e: Exception) {
+            Log.e("stopObservingGlucoseData", "Error removing observer: ${e.message}")
+          }
         }
-      } else {
-        observeGlucoseData(userToken)
       }
-    }*/
-
-    fun logLongJson(tag: String, message: String) {
-        val maxLogSize = 4000
-        for (i in 0..message.length / maxLogSize) {
-            val start = i * maxLogSize
-            val end = (i + 1) * maxLogSize
-            if (start < message.length) {
-                Log.d(tag, message.substring(start, minOf(end, message.length)))
-            }
-        }
+      glucoseObserver = null
+    } catch (e: Exception) {
+      Log.e("stopObservingGlucoseData", "Error stopping observer: ${e.message}")
     }
+  }
 
-    fun mapToDto(glucose: PocGlucose): GlucoseLog {
-        val dto: GlucoseLog = GlucoseLog()
-        dto.timeInMillis = glucose.getTimeInMillis()
-        dto.countdownMinutes = glucose.getCountdownMinutes()
-        dto.countdownHours = glucose.getCountdownHours()
-        dto.countdownDays = glucose.getCountdownDays()
-        dto.hypoglycemiaEarlyWarnMinutes = glucose.getHypoglycemiaEarlyWarnMinutes()
-        dto.showGlucoseMG = glucose.getShowGlucoseMG()
-        dto.glucoseId = glucose.getGlucoseId()
-        dto.name = glucose.getName()
-        dto.showGlucose = glucose.getShowGlucose()
-        dto.Ib = glucose.getIb()
-        dto.Iw = glucose.getIw()
-        dto.T = glucose.getT()
-        dto.year = glucose.getYear()
-        dto.month = glucose.getMonth()
-        dto.day = glucose.getDay()
-        dto.hour = glucose.getHour()
-        dto.minute = glucose.getMinute()
-
-        // Convert byte[] to List<Integer>
-        dto.bytes = ArrayList()
-        for (b in glucose.getBytes()) {
-            dto.bytes?.add(b.toInt() and 0xFF) // Prevent negative values
-        }
+  // Helper method for synchronous batch upload
+  private suspend fun uploadBatchSynchronously(json: String, batchIndex: Int): Boolean {
+    return suspendCoroutine { continuation ->
+      try {
+        authenticateSDKService.postCGMData(
+          environment = if ("uat".uppercase() == "PROD") TATVA_ENVIRONMENT.PROD else TATVA_ENVIRONMENT.STAGE,
+          data = json,
+          token = userToken,
+          responseListener = object : AuthenticateSDKService.ResponseListener {
+            override fun onResponseSuccess(response: String) {
+              continuation.resume(true)
+            }
+
+            override fun onResponseFail() {
+              continuation.resume(false)
+            }
+          }
+        )
+      } catch (e: Exception) {
+        Log.e("uploadBatchSynchronously", "Exception in batch $batchIndex: ${e.message}")
+        continuation.resume(false)
+      }
+    }
+  }
 
-        // Trend
-        val trendObj: TrendObject = TrendObject()
-        trendObj.trendId = glucose.getTrend().getTrendId()
-        trendObj.drawableId = glucose.getTrend().getDrawableId()
-        trendObj.widgetImg = glucose.getTrend().getWidgetImg()
-        trendObj.apsChangeRate = glucose.getTrend().getApsChangeRate()
-        dto.trendObject = trendObj
-
-        // Status
-        val statusObj: GlucoseStatusObject = GlucoseStatusObject()
-        statusObj.statusId = glucose.getGlucoseStatus().getStatusId()
-        dto.glucoseStatusObject = statusObj
-
-        // Error
-        val errorObj: ErrorObject = ErrorObject()
-        errorObj.errorId = glucose.getErrorCode().getErrorId()
-        errorObj.sound = glucose.getErrorCode().getSound().toString()
-        dto.errorObject = errorObj
-
-        return dto
+  private fun updateSyncMetadata(lastRecord: PocGlucose?) {
+    lastRecord?.let {
+      try {
+        val syncData = SyncMeta(
+          Date().time,
+          it.timeInMillis,
+          it.deviceId,
+          it.glucoseId
+        )
+        prefsHelper.lastSyncData = syncData
+        Log.d(
+          "Sync Metadata",
+          "Sync metadata updated: glucoseId=${it.glucoseId}, time=${it.timeInMillis}"
+        )
+      } catch (e: Exception) {
+        Log.e("updateSyncMetadata", "Error updating sync metadata: ${e.message}")
+      }
     }
+  }
 
 
-    @ReactMethod
-    fun sendDataToReact(data: String, status: String, eventName: String) {
-        Log.d("sendDataToReact: data ", data)
+  fun logLongJson(tag: String, message: String) {
+    val maxLogSize = 4000
+    for (i in 0..message.length / maxLogSize) {
+      val start = i * maxLogSize
+      val end = (i + 1) * maxLogSize
+      if (start < message.length) {
+        Log.d(tag, message.substring(start, minOf(end, message.length)))
+      }
+    }
+  }
+
+  fun mapToDto(glucose: PocGlucose): GlucoseLog {
+    val dto: GlucoseLog = GlucoseLog()
+    dto.timeInMillis = glucose.getTimeInMillis()
+    dto.countdownMinutes = glucose.getCountdownMinutes()
+    dto.countdownHours = glucose.getCountdownHours()
+    dto.countdownDays = glucose.getCountdownDays()
+    dto.hypoglycemiaEarlyWarnMinutes = glucose.getHypoglycemiaEarlyWarnMinutes()
+    dto.showGlucoseMG = glucose.getShowGlucoseMG()
+    dto.glucoseId = glucose.getGlucoseId()
+    dto.name = glucose.getName()
+    dto.showGlucose = glucose.getShowGlucose()
+    dto.Ib = glucose.getIb()
+    dto.Iw = glucose.getIw()
+    dto.T = glucose.getT()
+    dto.year = glucose.getYear()
+    dto.month = glucose.getMonth()
+    dto.day = glucose.getDay()
+    dto.hour = glucose.getHour()
+    dto.minute = glucose.getMinute()
+
+    // Convert byte[] to List<Integer>
+    dto.bytes = ArrayList()
+    for (b in glucose.getBytes()) {
+      dto.bytes?.add(b.toInt() and 0xFF) // Prevent negative values
+    }
 
-        try {
-            val map: WritableMap = Arguments.createMap().apply {
-                putString("data", data)
-                putString("status", status)
-            }
+    // Trend
+    val trendObj: TrendObject = TrendObject()
+    trendObj.trendId = glucose.getTrend().getTrendId()
+    trendObj.drawableId = glucose.getTrend().getDrawableId()
+    trendObj.widgetImg = glucose.getTrend().getWidgetImg()
+    trendObj.apsChangeRate = glucose.getTrend().getApsChangeRate()
+    dto.trendObject = trendObj
+
+    // Status
+    val statusObj: GlucoseStatusObject = GlucoseStatusObject()
+    statusObj.statusId = glucose.getGlucoseStatus().getStatusId()
+    dto.glucoseStatusObject = statusObj
+
+    // Error
+    val errorObj: ErrorObject = ErrorObject()
+    errorObj.errorId = glucose.getErrorCode().getErrorId()
+    errorObj.sound = glucose.getErrorCode().getSound().toString()
+    dto.errorObject = errorObj
+
+    return dto
+  }
+
+
+  @ReactMethod
+  fun sendDataToReact(data: String, status: String, eventName: String) {
+    Log.d("sendDataToReact: data ", data)
+
+    try {
+      val map: WritableMap = Arguments.createMap().apply {
+        putString("data", data)
+        putString("status", status)
+      }
 
-            Log.d("sendDataToReact: ", map.toString())
+      Log.d("sendDataToReact: ", map.toString())
 
-            mReactContext?.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-                ?.emit(eventName, map)
-        } catch (e: Exception) {
-            Log.e("Error sendDataToReact: ", e.message.toString())
-            e.printStackTrace()
-        }
+      mReactContext?.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+        ?.emit(eventName, map)
+    } catch (e: Exception) {
+      Log.e("Error sendDataToReact: ", e.message.toString())
+      e.printStackTrace()
     }
+  }
 
 }