react-native-mytatva-rn-sdk 1.2.67 → 1.2.68

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

@@ -49,6 +49,8 @@ import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
 import org.json.JSONObject
 import java.io.File
 import java.text.SimpleDateFormat
@@ -56,6 +58,9 @@ import java.util.Date
 import java.util.Locale
 import java.util.Timer
 import java.util.TimerTask
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.ConcurrentLinkedQueue
+import java.util.concurrent.atomic.AtomicBoolean
 import kotlin.coroutines.resume
 import kotlin.coroutines.suspendCoroutine
 
@@ -69,11 +74,14 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
     var prefsHelper: SharedPreferencesLibraryUtil? = null
     private val apiScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
     private var debounceJob: Job? = null
-    private var isBatchProcessing = false
+    private val isBatchProcessing = AtomicBoolean(false)
     private var lastDeviceStatus: String? = null
     private var glucoseObserver: Observer<PocGlucose?>? = null
     private var isObserving = false
-    private var lastProcessedSyncTimeInMillis: Long? = null
+    private val processedGlucoseIds = ConcurrentHashMap.newKeySet<Int>()
+    private val pendingDataQueue = ConcurrentLinkedQueue<PocGlucose>()
+    private val metadataLock = Mutex()
+    private var uploadJob: Job? = null
 
     init {
         mReactContext = reactContext
@@ -412,56 +420,42 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                 )
                 return
             }
-            if (isBatchProcessing) {
+
+            // Don't prevent observation during batch processing - they can coexist
+            // Just log it for monitoring
+            if (isBatchProcessing.get()) {
                 Log.d(
-                    "observeAllGlucoseData",
-                    "Batch processing in progress, skipping duplicate call"
+                    "observeGlucoseData",
+                    "Batch processing in progress, but starting observer anyway"
                 )
-                return
             }
 
             // Remove existing observer if any to prevent memory leaks
-            stopObservingGlucoseData()
+            if (glucoseObserver != null) {
+                stopObservingGlucoseDataInternal()
+            }
 
-            // Wait a bit for cleanup to complete
-            Handler(Looper.getMainLooper()).postDelayed({
+            // Create new observer immediately without delay to prevent data loss
+            Handler(Looper.getMainLooper()).post {
                 // Create new observer with explicit nullable parameter type
                 glucoseObserver = Observer<PocGlucose?> { pocGlucose ->
-                    val currentTime = System.currentTimeMillis()
-                    var dataAge = System.currentTimeMillis()
-
-                    val lastSyncData = prefsHelper?.lastSyncData
-                    val currentSyncTimeInMillis = lastSyncData?.timeInMillis
-
-                    if (lastSyncData != null) {
-                        dataAge = currentTime - lastSyncData.timeInMillis
+                    if (pocGlucose == null) {
+                        Log.d("observeGlucoseData", "Received null glucose data - skipping")
+                        return@Observer
                     }
 
-                    // Only proceed if timeInMillis is different from last processed
-                    if (currentSyncTimeInMillis != null && lastProcessedSyncTimeInMillis != null && currentSyncTimeInMillis == lastProcessedSyncTimeInMillis) {
-                        Log.d("SyncTimeCheck", "Duplicate sync time, skipping function calls")
+                    // Check for duplicate using glucoseId instead of timestamp
+                    val glucoseId = pocGlucose.glucoseId ?: run {
+                        Log.w("observeGlucoseData", "Glucose ID is null, skipping")
                         return@Observer
                     }
 
-                    if ((pocGlucose != null && lastSyncData == null) || (pocGlucose != null && lastSyncData != null && dataAge <= 4 * 60 * 1000L)) {
-                        handleGlucoseData(pocGlucose, envType)
-                        Log.d(
-                            "observeGlucoseData",
-                            "Received glucose data - processing"
-                        )
-                        // Update last processed sync time
-                        lastProcessedSyncTimeInMillis = currentSyncTimeInMillis
+                    // Add to queue for processing - ensures no data is lost
+                    if (pendingDataQueue.offer(pocGlucose)) {
+                        Log.d("observeGlucoseData", "Added glucose data to queue: $glucoseId")
+                        triggerDataUpload(envType)
                     } else {
-
-                        Handler(Looper.getMainLooper()).postDelayed({
-                            observeAllGlucoseData(userToken, isForClear, envType)
-                        }, 100)
-                        Log.d(
-                            "observeGlucoseData",
-                            "Received null glucose data - skipping processing"
-                        )
-                        // Update last processed sync time
-                        lastProcessedSyncTimeInMillis = currentSyncTimeInMillis
+                        Log.e("observeGlucoseData", "Failed to add data to queue: $glucoseId")
                     }
                 }
 
@@ -477,7 +471,7 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                         isObserving = false
                     }
                 }
-            }, 50) // Small delay to ensure previous cleanup is complete
+            }
 
         } catch (e: Exception) {
             Log.e("observeGlucoseData", "observeGlucoseData: ${e.message}")
@@ -487,6 +481,56 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
         }
     }
 
+    // New method to handle data upload from queue
+    private fun triggerDataUpload(envType: String) {
+        // If upload is already in progress, just return
+        if (uploadJob?.isActive == true) {
+            return
+        }
+
+        uploadJob = apiScope.launch {
+            while (pendingDataQueue.isNotEmpty()) {
+                val pocGlucose = pendingDataQueue.poll() ?: continue
+
+                // Check for duplicate using glucoseId
+                val glucoseId = pocGlucose.glucoseId ?: continue
+                
+                if (!processedGlucoseIds.add(glucoseId)) {
+                    Log.d("triggerDataUpload", "Already processed: $glucoseId, skipping")
+                    continue
+                }
+
+                val currentTime = System.currentTimeMillis()
+                val lastSyncData = prefsHelper?.lastSyncData
+                val dataAge = if (lastSyncData != null) {
+                    currentTime - lastSyncData.timeInMillis
+                } else {
+                    0L
+                }
+
+                // If data is recent (within 4 minutes), upload immediately
+                if (lastSyncData == null || dataAge <= 4 * 60 * 1000L) {
+                    handleGlucoseData(pocGlucose, envType)
+                    Log.d("triggerDataUpload", "Uploaded recent data: $glucoseId")
+                } else {
+                    // Data is old, need batch processing
+                    // Put it back in queue for batch to handle
+                    pendingDataQueue.offer(pocGlucose)
+                    Log.d("triggerDataUpload", "Old data detected, triggering batch: $glucoseId")
+                    
+                    // Trigger batch process on main thread
+                    withContext(Dispatchers.Main) {
+                        observeAllGlucoseData(userToken, false, envType)
+                    }
+                    break // Exit loop to let batch take over
+                }
+
+                // Small delay to avoid overwhelming the API
+                delay(100)
+            }
+        }
+    }
+
     private fun handleGlucoseData(pocGlucose: PocGlucose, envType: String) {
         try {
             // Additional safety check
@@ -592,8 +636,9 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
     fun observeAllGlucoseData(token: String, isForClear: Boolean = false, envType: String) {
         Log.d("function call", "observeAllGlucoseData")
 
-        if (isBatchProcessing) {
-            Log.d("observeAllGlucoseData", "Batch processing in progress, skipping duplicate call")
+        // Use atomic compareAndSet to prevent concurrent batch processing
+        if (!isBatchProcessing.compareAndSet(false, true)) {
+            Log.d("observeAllGlucoseData", "Batch processing already in progress, skipping duplicate call")
             return
         }
 
@@ -601,60 +646,94 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
         env = envType
 
         CoroutineScope(Dispatchers.IO).launch {
-            // Step 1: Clear DB first if needed
-         /*   if (isForClear) {
-                Log.d("delete1111-observe", "observe delete")
-                mModel.clearAllGlucoseAndDeviceData() // suspend or blocking DB operation
-            } */
+            try {
+                // Process any pending data from queue first to ensure nothing is lost
+                val pendingData = mutableListOf<PocGlucose>()
+                while (pendingDataQueue.isNotEmpty()) {
+                    pendingDataQueue.poll()?.let { pendingData.add(it) }
+                }
+                
+                if (pendingData.isNotEmpty()) {
+                    Log.d("observeAllGlucoseData", "Found ${pendingData.size} items in pending queue")
+                }
 
-            // Step 2: Back to main thread to stop observers and proceed
-            withContext(Dispatchers.Main) {
-                stopObservingGlucoseData()
+                val lastSyncData = prefsHelper?.lastSyncData
+                Log.d("lastSyncData: ", Gson().toJson(lastSyncData).toString())
 
-                Handler(Looper.getMainLooper()).postDelayed({
-                    try {
-                        val lastSyncData = prefsHelper?.lastSyncData
-                        Log.d("lastSyncData: ", Gson().toJson(lastSyncData).toString())
-
-                        val currentTime = System.currentTimeMillis()
-                        val dataAge =
-                            if (lastSyncData != null) currentTime - lastSyncData.timeInMillis else 0L
-
-                        if (lastSyncData != null && dataAge > 3 * 60 * 1000L) {
-                            isBatchProcessing = true
-                            CoroutineScope(Dispatchers.IO).launch {
-                                val glucoseData =
-                                    mModel.getGlucoseBetweenTime(lastSyncData.timeInMillis)
-
-                                Log.d("observeAllGlucoseData: ", glucoseData.toString())
-                                Log.d("Last sync time: ", lastSyncData.lastSyncTime.toString())
-                                Log.d("current time: ", System.currentTimeMillis().toString())
-
-                                if (!glucoseData.isNullOrEmpty()) {
-                                    processBatchDataAndStartObserver(
-                                        glucoseData,
-                                        isForClear,
-                                        envType
-                                    )
-                                } else {
-                                    Log.d(
-                                        "observeAllGlucoseData",
-                                        "No historical data found, starting live observation"
-                                    )
-                                    withContext(Dispatchers.Main) {
-                                        observeGlucoseData(userToken, isForClear, envType)
-                                    }
-                                }
+                val currentTime = System.currentTimeMillis()
+                val dataAge = if (lastSyncData != null) currentTime - lastSyncData.timeInMillis else 0L
+
+                if (lastSyncData != null && dataAge > 3 * 60 * 1000L) {
+                    val glucoseData = mModel.getGlucoseBetweenTime(lastSyncData.timeInMillis)
+
+                    Log.d("observeAllGlucoseData", "Retrieved ${glucoseData?.size ?: 0} records from DB")
+                    
+                    // Combine database data with pending queue data
+                    val allData = mutableListOf<PocGlucose>()
+                    glucoseData?.let { allData.addAll(it) }
+                    allData.addAll(pendingData)
+
+                    // Log BEFORE sorting to see database order
+                    allData.take(5).forEachIndexed { i, data ->
+                        Log.d("BEFORE Sort [$i]", "timeInMillis: ${data.timeInMillis}, glucoseId: ${data.glucoseId}")
+                    }
+
+                    // Sort by timestamp to ensure chronological order (oldest first)
+                    // This is critical when device reconnects after being out of range
+                    val sortedGlucoseData = allData.sortedBy { it.timeInMillis }
+
+                    // Log AFTER sorting to verify chronological order
+                    sortedGlucoseData.take(5).forEachIndexed { i, data ->
+                        Log.d("AFTER Sort [$i]", "timeInMillis: ${data.timeInMillis}, glucoseId: ${data.glucoseId}")
+                    }
+                    
+                    if (sortedGlucoseData.isNotEmpty()) {
+                        Log.d("observeAllGlucoseData", "✅ Sorted ${sortedGlucoseData.size} records chronologically")
+                        Log.d("observeAllGlucoseData", "Oldest: ${sortedGlucoseData.first().timeInMillis}")
+                        Log.d("observeAllGlucoseData", "Newest: ${sortedGlucoseData.last().timeInMillis}")
+                    }
+
+                    if (sortedGlucoseData.isNotEmpty()) {
+                        processBatchDataAndStartObserver(
+                            sortedGlucoseData,
+                            isForClear,
+                            envType
+                        )
+                    } else {
+                        Log.d(
+                            "observeAllGlucoseData",
+                            "No historical data found, starting live observation"
+                        )
+                        withContext(Dispatchers.Main) {
+                            if (!isObserving) {
+                                observeGlucoseData(userToken, isForClear, envType)
                             }
-                        } else {
-                            isBatchProcessing = false
+                        }
+                    }
+                } else {
+                    // No batch needed, but process pending data if any
+                    if (pendingData.isNotEmpty()) {
+                        Log.d("observeAllGlucoseData", "Processing ${pendingData.size} pending items")
+                        pendingData.forEach { data ->
+                            val glucoseId = data.glucoseId
+                            if (glucoseId != null && processedGlucoseIds.add(glucoseId)) {
+                                handleGlucoseData(data, envType)
+                            }
+                        }
+                    }
+                    
+                    withContext(Dispatchers.Main) {
+                        if (!isObserving) {
                             observeGlucoseData(userToken, isForClear, envType)
                         }
-                    } catch (e: Exception) {
-                        isBatchProcessing = false
-                        observeGlucoseData(userToken, isForClear, envType)
                     }
-                }, 100)
+                }
+            } catch (e: Exception) {
+                Log.e("observeAllGlucoseData", "Error in batch processing: ${e.message}", e)
+            } finally {
+                // Always reset the flag
+                isBatchProcessing.set(false)
+                Log.d("observeAllGlucoseData", "Batch processing completed, flag reset")
             }
         }
     }
@@ -679,8 +758,9 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                 Log.w("processBatchDataAndStartObserver", "Batch processing had failures")
             }
 
+            // Don't reset flag here - it's reset in observeAllGlucoseData's finally block
+            
             // Ensure we're on main thread and not already observing
-            isBatchProcessing = false
             withContext(Dispatchers.Main) {
                 if (!isObserving) {
                     Log.d(
@@ -699,7 +779,6 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
         } catch (e: Exception) {
             Log.e("processBatchDataAndStartObserver", "Error in batch processing: ${e.message}")
             // Start live observation even on error
-            isBatchProcessing = false
             withContext(Dispatchers.Main) {
                 if (!isObserving) {
                     observeGlucoseData(userToken, isForClear, envType)
@@ -733,6 +812,9 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
             // Cancel all coroutines
             debounceJob?.cancel()
             debounceJob = null
+            
+            uploadJob?.cancel()
+            uploadJob = null
 
             // Reset user token
             userToken = ""
@@ -740,12 +822,16 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
             // Reset device status
             lastDeviceStatus = null
 
+            // Clear processed IDs and pending queue
+            processedGlucoseIds.clear()
+            pendingDataQueue.clear()
+            
+            // Reset batch processing flag
+            isBatchProcessing.set(false)
+
             // Clear any cached data if needed
             prefsHelper?.clearQRInformation() // if you have such method
 
-            // Reset last processed sync time
-            lastProcessedSyncTimeInMillis = null
-
         } catch (e: Exception) {
             Log.e("resetCgmState", "Error resetting CGM state: ${e.message}")
         }
@@ -814,13 +900,34 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                     continue
                 }
 
+                // Log the actual timestamps being sent to verify order
+                transformedLogs.forEachIndexed { i, log ->
+                    Log.d(
+                        "Batch $index Record $i",
+                        "timeInMillis: ${log.timeInMillis}, glucoseId: ${log.glucoseId}"
+                    )
+                }
+
                 val allResult = AllCGMLogRequest(vendor = "GoodFlip", logs = transformedLogs)
                 val json = Gson().toJson(allResult)
 
+                // Check if logs array is empty - skip API call if so
+                if (transformedLogs.isEmpty()) {
+                    Log.d(
+                        "processBatchDataSynchronously",
+                        "Batch $index skipped - logs array is empty, not hitting API"
+                    )
+                    continue
+                }
+
                 Log.d(
                     "Batch Upload",
                     "Processing batch $index with ${transformedLogs.size} records"
                 )
+                Log.d(
+                    "Batch Upload",
+                    "First timestamp: ${transformedLogs.firstOrNull()?.timeInMillis}, Last timestamp: ${transformedLogs.lastOrNull()?.timeInMillis}"
+                )
                 logLongJson("Batch $index JSON=>>> ", json)
 
                 val uploadSuccessful = uploadBatchSynchronously(json, index, envType)
@@ -864,6 +971,11 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
 
     @ReactMethod
     fun stopObservingGlucoseData() {
+        stopObservingGlucoseDataInternal()
+    }
+    
+    // Internal method that doesn't clear the queue (used during restarts)
+    private fun stopObservingGlucoseDataInternal() {
         Log.d("stopObservingGlucoseData", "Stopping glucose data observation")
 
         try {
@@ -890,9 +1002,6 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
             // Reset last device status
             lastDeviceStatus = null
 
-            // Reset last processed sync time
-            lastProcessedSyncTimeInMillis = null
-
         } catch (e: Exception) {
             Log.e("stopObservingGlucoseData", "Error stopping observer: ${e.message}")
         }
@@ -929,21 +1038,28 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
 
     private fun updateSyncMetadata(lastRecord: PocGlucose?) {
         lastRecord?.let {
-            try {
-                val syncData = SyncMeta(
-                    System.currentTimeMillis(),
-                    it.timeInMillis,
-                    it.deviceId,
-                    it.glucoseId
-                )
-                prefsHelper?.lastSyncData = syncData
-                lastProcessedSyncTimeInMillis = null
-                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}")
+            apiScope.launch {
+                metadataLock.withLock {
+                    try {
+                        val syncData = SyncMeta(
+                            System.currentTimeMillis(),
+                            it.timeInMillis,
+                            it.deviceId,
+                            it.glucoseId
+                        )
+                        prefsHelper?.lastSyncData = syncData
+                        
+                        // Mark this glucose ID as processed
+                        it.glucoseId?.let { id -> processedGlucoseIds.add(id) }
+                        
+                        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}")
+                    }
+                }
             }
         }
     }

package/ios/ViewModel/FinalViewModel.swift

@@ -429,6 +429,14 @@ class FinalViewModel: NSObject {
         let cgmLogs = filteredBatch.map { ReceiveDataToLog(data: $0) }
         let payload = Payload(logs: cgmLogs)
 
+        // Check if logs array is empty - skip API call if so
+        if cgmLogs.isEmpty {
+            print("Batch \(index + 1) skipped - logs array is empty, not hitting API")
+            // Move to next batch
+            self.uploadBatch(batches: batches, index: index + 1)
+            return
+        }
+
         print("====================================> called uploadBatch")
         API.shared.postCGMData(data: payload, environment: .stage) {
             print("====================================> uploaded successfully")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-mytatva-rn-sdk",
-  "version": "1.2.67",
+  "version": "1.2.68",
   "description": "a package to inject data into visit health pwa",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",