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

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

@@ -69,6 +69,8 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
     var prefsHelper: SharedPreferencesLibraryUtil
     private val apiScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
     private var debounceJob: Job? = null
+
+    @Volatile
     private var lastDeviceStatus: PocDevice? = null
 
     private var glucoseObserver: Observer<PocGlucose?>? = null
@@ -98,6 +100,11 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
     fun observeDeviceStatus(token: String) {
         try {
             userToken = token
+
+            // Reset previous state
+            lastDeviceStatus = null
+            debounceJob?.cancel()
+
             Handler(Looper.getMainLooper()).post {
                 mModel.device.observeForever { device ->
                     if (device != lastDeviceStatus) {
@@ -117,66 +124,112 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
     }
 
     @ReactMethod
-    fun observeTransmitterUnbindStatus(token: String) {
+    fun observeTransmitterUnbindStatus(token: String, apiResponse: 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) {
+            /*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()
+                  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
+                  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")
+                    println("Start Date: $startDate")
+                    println("End Date: $endDate")
 
-                            if (isCurrentDateInRange(startDate, endDate)) {
+                    if (isCurrentDateInRange(startDate, endDate)) {
 
-                                println("Current date is in range")
+                      println("Current date is in range")
 
-                                val pocDevice =
-                                    RepositoryDevice.getInstance(BApplication.getContext()).latestDeviceIoThread
+                      val pocDevice =
+                        RepositoryDevice.getInstance(BApplication.getContext()).latestDeviceIoThread
 
-                                if (pocDevice != null) {
-                                    Log.d("pocDevice logsss", pocDevice.toString())
+                      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")
+                        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
-                                    )
-                                }
+                        postEventDataToAPI(
+                          pocDevice,
+                          DeviceStatus.TRANSMITTER_DISCONNECT.id,
+                          sensorId
+                        )
+                      }
 
-                            } else {
-                                println("Current date is out of range")
-                            }
-                        } else {
-                            println("Start or End date not available")
-                        }
+                    } else {
+                      println("Current date is out of range")
                     }
+                  } else {
+                    println("Start or End date not available")
+                  }
+                }
+
+                override fun onResponseFail() {
+                }
+              }
+            )*/
 
-                    override fun onResponseFail() {
+            val response = Gson().fromJson(apiResponse, 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")
+            }
+
 
         } catch (e: Exception) {
             Log.e("observeTransmitterUnbindStatus", "observeTransmitterUnbindStatus: ${e.message}")
@@ -317,122 +370,71 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
         }
     }
 
-
-    /*@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
 
+            // Ensure we're not already observing
+            if (isObserving && glucoseObserver != null) {
+                Log.d(
+                    "observeGlucoseData",
+                    "Already observing glucose data, skipping duplicate setup"
+                )
+                return
+            }
+
             // Remove existing observer if any to prevent memory leaks
             stopObservingGlucoseData()
 
-            // 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")
+            // Wait a bit for cleanup to complete
+            Handler(Looper.getMainLooper()).postDelayed({
+                // 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)
+                        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"
+                        )
+                    }
                 }
-            }
 
-            // Add observer on main thread
-            Handler(Looper.getMainLooper()).post {
+                // Add observer on main thread
                 glucoseObserver?.let { observer ->
                     try {
                         mModel.latestGlucose.observeForever(observer)
                         isObserving = true
-                        Log.d("observeGlucoseData", "Observer added successfully")
+                        Log.d("observeGlucoseData", "Live glucose observer started successfully")
                     } catch (e: Exception) {
                         Log.e("observeGlucoseData", "Error adding observer: ${e.message}")
                         glucoseObserver = null
+                        isObserving = false
                     }
                 }
-            }
+            }, 50) // Small delay to ensure previous cleanup is complete
+
         } catch (e: Exception) {
             Log.e("observeGlucoseData", "observeGlucoseData: ${e.message}")
             e.printStackTrace()
+            isObserving = false
+            glucoseObserver = null
         }
     }
 
-
     private fun handleGlucoseData(pocGlucose: PocGlucose) {
         try {
             // Additional safety check
@@ -534,186 +536,252 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
         }
     }
 
-    /*@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
-              )
-            )
-          }
-        } else {
-          observeGlucoseData(userToken)
-        }
-
-      } catch (e: Exception) {
-        Log.e("observeAllGlucoseData", "observeAllGlucoseData Error: ${e.message}")
-      }
-    }*/
-
 
     @ReactMethod
     fun observeAllGlucoseData(token: String) {
         userToken = token
-        Log.e("userToken", "userToken: $token")
 
-        // Stop current observation to prevent duplicates
+        // FIX: Ensure proper cleanup and reset state
         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)
+        // 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())
+
+                if (lastSyncData != null) {
+                    CoroutineScope(Dispatchers.IO).launch {
+                        val glucoseData = mModel.getGlucoseBetweenTime(lastSyncData.lastSyncTime)
+                        if (glucoseData != null && glucoseData.isNotEmpty()) {
+                            processBatchDataAndStartObserver(glucoseData)
+                        } else {
+                            Log.d(
+                                "observeAllGlucoseData",
+                                "No historical data found, starting live observation"
+                            )
+                            Handler(Looper.getMainLooper()).post {
+                                observeGlucoseData(userToken)
+                            }
+                        }
                     }
+                } else {
+                    observeGlucoseData(userToken)
                 }
-            } else {
+            } catch (e: Exception) {
+                Log.e("observeAllGlucoseData", "observeAllGlucoseData Error: ${e.message}")
                 observeGlucoseData(userToken)
             }
+        }, 100) // Small delay to ensure cleanup
+    }
+
+    // New method to handle batch processing and ensure proper sequencing
+    private suspend fun processBatchDataAndStartObserver(dataList: List<PocGlucose>) {
+        try {
+            Log.d(
+                "processBatchDataAndStartObserver",
+                "Starting batch processing with ${dataList.size} records"
+            )
+
+            val success = processBatchDataSynchronously(dataList)
+
+            if (success) {
+                Log.d("processBatchDataAndStartObserver", "Batch processing completed successfully")
+            } else {
+                Log.w("processBatchDataAndStartObserver", "Batch processing had failures")
+            }
+
+            // Ensure we're on main thread and not already observing
+            Handler(Looper.getMainLooper()).post {
+                if (!isObserving) {
+                    Log.d(
+                        "processBatchDataAndStartObserver",
+                        "Starting live observer after batch completion"
+                    )
+                    observeGlucoseData(userToken)
+                } else {
+                    Log.d(
+                        "processBatchDataAndStartObserver",
+                        "Already observing, skipping duplicate observer setup"
+                    )
+                }
+            }
+
         } catch (e: Exception) {
-            Log.e("observeAllGlucoseData", "observeAllGlucoseData Error: ${e.message}")
+            Log.e("processBatchDataAndStartObserver", "Error in batch processing: ${e.message}")
+            // Start live observation even on error
+            Handler(Looper.getMainLooper()).post {
+                if (!isObserving) {
+                    observeGlucoseData(userToken)
+                }
+            }
         }
     }
 
     @ReactMethod
-    fun stopObservingGlucoseData() {
+    fun resetCgmState() {
+        Log.d("resetCgmState", "Resetting CGM state for logout")
+
         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
+            // Stop all observations
+            stopObservingGlucoseData()
+
+            // Cancel all coroutines
+            debounceJob?.cancel()
+            debounceJob = null
+
+            // Reset user token
+            userToken = ""
+
+            // Reset device status
+            lastDeviceStatus = null
+
+            // Clear any cached data if needed
+            // prefsHelper.clearCache() // if you have such method
+
         } catch (e: Exception) {
-            Log.e("stopObservingGlucoseData", "Error stopping observer: ${e.message}")
+            Log.e("resetCgmState", "Error resetting CGM state: ${e.message}")
         }
     }
 
-    fun getGlucoseDataAndUploadInBatch(dataList: List<PocGlucose>) {
+    // Updated batch processing method with better sync control
+    private suspend fun processBatchDataSynchronously(dataList: List<PocGlucose>): Boolean {
         if (dataList.isEmpty()) {
-            Log.d("getGlucoseDataAndUploadInBatch", "No data to upload, starting live observation")
-            if (!isObserving) {
-                observeGlucoseData(userToken)
-            }
-            return
+            Log.d("processBatchDataSynchronously", "No data to upload")
+            return true
         }
 
         val batchSize = 40
         val chunks = dataList.chunked(batchSize)
+        var lastSyncedRecord: PocGlucose? = null
+        var allBatchesSuccessful = true
 
-        Log.d("getGlucoseDataAndUploadInBatch", "Starting batch upload with ${chunks.size} batches")
-
-        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
-                    }
+        Log.d("processBatchDataSynchronously", "Starting batch upload with ${chunks.size} batches")
 
-                    val allResult = AllCGMLogRequest(vendor = "GoodFlip", logs = transformedLogs)
-                    val json = Gson().toJson(allResult)
+        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
+                        )
+                    )
+                }
 
-                    Log.d("Batch Upload JSON", "Batch $index with ${transformedLogs.size} records")
-                    logLongJson("Batch $index JSON=>>> ", json)
+                if (transformedLogs.isEmpty()) {
+                    Log.d(
+                        "processBatchDataSynchronously",
+                        "Batch $index skipped - no valid glucose readings"
+                    )
+                    continue
+                }
 
-                    val uploadSuccessful = uploadBatchSynchronously(json, index)
+                val allResult = AllCGMLogRequest(vendor = "GoodFlip", logs = transformedLogs)
+                val json = Gson().toJson(allResult)
 
-                    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
-                    }
+                Log.d(
+                    "Batch Upload",
+                    "Processing batch $index with ${transformedLogs.size} records"
+                )
+                logLongJson("Batch $index JSON=>>> ", json)
 
-                    delay(500L) // Rate limiting between batches
+                val uploadSuccessful = uploadBatchSynchronously(json, index)
 
-                } catch (e: Exception) {
-                    Log.e("Batch Upload", "❌ Batch $index exception: ${e.message}")
+                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
-                    break
+                    Log.e("Batch Upload", "❌ Batch $index failed")
+                    // Continue with next batch instead of breaking (optional based on your needs)
+                    // break
                 }
+
+                // Rate limiting between batches
+                delay(500L)
+
+            } catch (e: Exception) {
+                Log.e("Batch Upload", "❌ Batch $index exception: ${e.message}")
+                allBatchesSuccessful = false
+                // Continue processing other batches
             }
+        }
 
-            // Handle last synced record error status
-            lastSyncedRecord?.let { record ->
-                if (record.errorCode != enumError.NONE) {
-                    handleGlucoseError(record)
-                }
+        // Handle error status for the last processed record
+        lastSyncedRecord?.let { record ->
+            if (record.errorCode != enumError.NONE) {
+                handleGlucoseError(record)
             }
+        }
+
+        Log.d(
+            "processBatchDataSynchronously",
+            "Batch processing completed. Overall success: $allBatchesSuccessful"
+        )
+        return allBatchesSuccessful
+    }
 
-            Log.d("Batch Upload", "Batch upload completed. Success: $allBatchesSuccessful")
 
-            // Only start observing new data if we're not already doing so
-            if (!isObserving) {
-                observeGlucoseData(userToken)
+    @ReactMethod
+    fun stopObservingGlucoseData() {
+        Log.d("stopObservingGlucoseData", "Stopping glucose data observation")
+
+        try {
+            // Cancel any ongoing coroutines
+            debounceJob?.cancel()
+            debounceJob = null
+
+            // Remove observer on main thread with completion callback
+            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}")
+                    }
+                }
             }
+
+            // Reset observer reference
+            glucoseObserver = null
+
+            // Reset last device status
+            lastDeviceStatus = null
+
+        } catch (e: Exception) {
+            Log.e("stopObservingGlucoseData", "Error stopping observer: ${e.message}")
         }
     }
 
@@ -752,153 +820,16 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                     it.glucoseId
                 )
                 prefsHelper.lastSyncData = syncData
-                Log.d("Sync Metadata", "Last sync data stored: ${Gson().toJson(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}")
             }
         }
     }
 
-    /*fun getGlucoseDataAndUploadInBatch(dataList: List<PocGlucose>) {
-      if (dataList.isNotEmpty()) {
-        val batchSize = 40
-
-        val chunks = dataList.chunked(batchSize)
-
-        CoroutineScope(Dispatchers.IO).launch {
-
-          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 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()
-                      )
-                    }
-                  }
-
-                  override fun onResponseFail() {
-                    Log.e("Batch Upload", "❌ Batch $index failed")
-                  }
-                }
-              )
-
-              delay(500L)
-            } catch (e: Exception) {
-              Log.e("Batch Upload", "❌ Batch $index exception: ${e.message}")
-              break // Optional: stop further processing if exception occurs
-            }
-          }
-
-
-          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.e("Batch Upload", "All data uploaded")
-
-          observeGlucoseData(userToken)
-        }
-      } else {
-        observeGlucoseData(userToken)
-      }
-    }*/
 
     fun logLongJson(tag: String, message: String) {
         val maxLogSize = 4000
@@ -980,5 +911,6 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
         }
     }
 
+
 }