react-native-mytatva-rn-sdk 1.2.46 → 1.2.49

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

@@ -2,6 +2,8 @@ package com.mytatvarnsdk
 
 import android.app.Application
 import android.bluetooth.BluetoothAdapter
+import android.bluetooth.BluetoothManager
+import android.content.Context
 import android.content.Intent
 import android.content.pm.PackageManager
 import android.os.Build
@@ -52,10 +54,13 @@ import kotlinx.coroutines.Job
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 import org.json.JSONObject
 import java.text.SimpleDateFormat
 import java.util.Date
 import java.util.Locale
+import java.util.Timer
+import java.util.TimerTask
 import kotlin.coroutines.resume
 import kotlin.coroutines.suspendCoroutine
 
@@ -69,11 +74,11 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
     var prefsHelper: SharedPreferencesLibraryUtil
     private val apiScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
     private var debounceJob: Job? = null
-
+    private var isBatchProcessing = false
     private var lastDeviceStatus: String? = null
-
     private var glucoseObserver: Observer<PocGlucose?>? = null
     private var isObserving = false
+    private var lastProcessedSyncTimeInMillis: Long? = null
 
     init {
         mReactContext = reactContext
@@ -107,8 +112,7 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
             Handler(Looper.getMainLooper()).post {
                 mModel.device.observeForever { device ->
                     if (device != null) {
-                        postEventDataToAPI(device, "", device?.qrMessage ?: "")
-
+                        postEventDataToAPI(device, "", device.qrMessage ?: "")
                         Log.d("observeDeviceStatus: ", device.toString())
                     }
                 }
@@ -119,7 +123,7 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
     }
 
     @ReactMethod
-    fun observeTransmitterUnbindStatus(token: String, apiResponse: String) {
+    fun observeTransmitterUnbindStatus(token: String, apiResponse: String?) {
         try {
             if (apiResponse != null && apiResponse.isNotEmpty()) {
                 userToken = token
@@ -189,19 +193,13 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                     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,
@@ -210,8 +208,6 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                                 )
                             }
                         } else {
-                            Log.d("pocDevice logsss", "Data null")
-
                             postEventDataToAPI(
                                 pocDevice,
                                 DeviceStatus.TRANSMITTER_DISCONNECT.id,
@@ -231,65 +227,93 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
         }
     }
 
+    private var debounceDeviceTimer: Timer? = null
+    private var isDebounceTimerActive: Boolean = false
+
+
     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()) {
+                val status: String = mStatus.ifEmpty {
                     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 -> ""
                     }
-                } else {
-                    mStatus
                 }
 
-                Log.d("postEventDataToAPI: ", "Device Event Status==> $status")
-
-                if (status.isNotEmpty()) {
-                    if (status != lastDeviceStatus) {
+                Log.d("Device event Status", "Device event Status: $status")
 
-                        lastDeviceStatus = status
-                        Log.d("postEventDataToAPI: ", "Device Event Status API==> $status")
+                if (status == DeviceStatus.DISCONNECTED.id && !isDebounceTimerActive) {
+                    // Start debounce timer for 1 minutes
+                    debounceDeviceTimer = Timer()
+                    isDebounceTimerActive = true
 
-                        val rawData = JSONObject().apply {
-                            put("transmitterName", device?.name ?: "")
-                            put("SensorId", sensorId ?: "")
-                            put("Sensor", sensorId ?: "")
-                            put("timeInMillis", System.currentTimeMillis())
+                    debounceDeviceTimer?.schedule(object : TimerTask() {
+                        override fun run() {
+                            isDebounceTimerActive = false
+                            callEventAPI(device, status, sensorId)
                         }
+                    }, 1 * 60 * 1000) // 1 minutes in milliseconds
 
-                        val obj = JSONObject().apply {
-                            put("sensorId", sensorId ?: "")
-                            put("status", status)
-                            put("rawData", rawData)
-                        }
+                    Log.d("Debounce", "Timer started for disconnection reminder")
+                } else {
+                    // Either device is not disconnected or timer already running
+                    debounceDeviceTimer?.cancel()
+                    debounceDeviceTimer = null
+                    isDebounceTimerActive = false
 
-                        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() {}
-                            }
-                        )
+                    Log.d("Debounce", "Timer cancelled, event triggered immediately")
 
-                        resetDebounceTimer()
-                    }
+                    callEventAPI(device, status, sensorId)
                 }
+
             } catch (e: Exception) {
                 e.printStackTrace()
             }
         }
     }
 
+    private fun callEventAPI(device: PocDevice?, status: String, sensorId: String?) {
+        Log.d("Device event Status", "Last Device event lastDeviceStatus API: $lastDeviceStatus")
+
+        if (status.isNotEmpty() && status != lastDeviceStatus) {
+            lastDeviceStatus = status
+
+            Log.d("Device event Status", "Device event Status API: $status")
+
+            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() {}
+                }
+            )
+
+            resetDebounceTimer()
+        }
+    }
+
     private fun resetDebounceTimer() {
         debounceJob?.cancel() // Cancel any existing timer
         debounceJob = apiScope.launch {
@@ -360,6 +384,13 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                 )
                 return
             }
+            if (isBatchProcessing) {
+                Log.d(
+                    "observeAllGlucoseData",
+                    "Batch processing in progress, skipping duplicate call"
+                )
+                return
+            }
 
             // Remove existing observer if any to prevent memory leaks
             stopObservingGlucoseData()
@@ -371,22 +402,38 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                     val currentTime = System.currentTimeMillis()
                     var dataAge = System.currentTimeMillis()
 
-                    if (prefsHelper.lastSyncData != null) {
-                        dataAge = currentTime - prefsHelper.lastSyncData.timeInMillis
+                    val lastSyncData = prefsHelper.lastSyncData
+                    val currentSyncTimeInMillis = lastSyncData?.timeInMillis
+
+                    if (lastSyncData != null) {
+                        dataAge = currentTime - lastSyncData.timeInMillis
+                    }
+
+                    // 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")
+                        return@Observer
                     }
 
-                    if ((pocGlucose != null && prefsHelper.lastSyncData == null) || (pocGlucose != null && prefsHelper.lastSyncData != null && dataAge <= 4 * 60 * 1000L)) {
+                    if ((pocGlucose != null && lastSyncData == null) || (pocGlucose != null && lastSyncData != null && dataAge <= 4 * 60 * 1000L)) {
                         handleGlucoseData(pocGlucose)
                         Log.d(
                             "observeGlucoseData",
                             "Received glucose data - processing"
                         )
+                        // Update last processed sync time
+                        lastProcessedSyncTimeInMillis = currentSyncTimeInMillis
                     } else {
-                        observeAllGlucoseData(userToken)
+
+                        Handler(Looper.getMainLooper()).postDelayed({
+                            observeAllGlucoseData(userToken)
+                        }, 100)
                         Log.d(
                             "observeGlucoseData",
                             "Received null glucose data - skipping processing"
                         )
+                        // Update last processed sync time
+                        lastProcessedSyncTimeInMillis = currentSyncTimeInMillis
                     }
                 }
 
@@ -515,6 +562,11 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
 
     @ReactMethod
     fun observeAllGlucoseData(token: String) {
+        Log.d("function call", "observeAllGlucoseData")
+        if (isBatchProcessing) {
+            Log.d("observeAllGlucoseData", "Batch processing in progress, skipping duplicate call")
+            return
+        }
         userToken = token
 
         // FIX: Ensure proper cleanup and reset state
@@ -525,10 +577,19 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
             try {
                 val lastSyncData = prefsHelper.lastSyncData
                 Log.d("lastSyncData: ", Gson().toJson(lastSyncData).toString())
+                val currentTime = System.currentTimeMillis()
+                var dataAge = System.currentTimeMillis()
+
+                if (prefsHelper.lastSyncData != null) {
+                    dataAge = currentTime - prefsHelper.lastSyncData.timeInMillis
+                }
 
-                if (lastSyncData != null) {
+                if (lastSyncData != null && dataAge > 3 * 60 * 1000L) {
+                    isBatchProcessing = true
                     CoroutineScope(Dispatchers.IO).launch {
-                        val glucoseData = mModel.getGlucoseBetweenTime(lastSyncData.lastSyncTime)
+
+                        val glucoseData = mModel.getGlucoseBetweenTime(lastSyncData.timeInMillis)
+
 
                         Log.d("observeAllGlucoseData: ", glucoseData.toString())
                         Log.d("Last sync time: ", lastSyncData.lastSyncTime.toString())
@@ -541,16 +602,18 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                                 "observeAllGlucoseData",
                                 "No historical data found, starting live observation"
                             )
-                            Handler(Looper.getMainLooper()).post {
+
+                            withContext(Dispatchers.Main) {
                                 observeGlucoseData(userToken)
                             }
                         }
                     }
                 } else {
+                    isBatchProcessing = false
                     observeGlucoseData(userToken)
                 }
             } catch (e: Exception) {
-                Log.e("observeAllGlucoseData", "observeAllGlucoseData Error: ${e.message}")
+                isBatchProcessing = false
                 observeGlucoseData(userToken)
             }
         }, 100) // Small delay to ensure cleanup
@@ -573,7 +636,8 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
             }
 
             // Ensure we're on main thread and not already observing
-            Handler(Looper.getMainLooper()).post {
+            isBatchProcessing = false
+            withContext(Dispatchers.Main) {
                 if (!isObserving) {
                     Log.d(
                         "processBatchDataAndStartObserver",
@@ -591,7 +655,8 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
         } catch (e: Exception) {
             Log.e("processBatchDataAndStartObserver", "Error in batch processing: ${e.message}")
             // Start live observation even on error
-            Handler(Looper.getMainLooper()).post {
+            isBatchProcessing = false
+            withContext(Dispatchers.Main) {
                 if (!isObserving) {
                     observeGlucoseData(userToken)
                 }
@@ -620,6 +685,9 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
             // 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}")
         }
@@ -761,6 +829,9 @@ 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}")
         }
@@ -801,6 +872,7 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                     it.glucoseId
                 )
                 prefsHelper.lastSyncData = syncData
+                lastProcessedSyncTimeInMillis = null
                 Log.d(
                     "Sync Metadata",
                     "Sync metadata updated: glucoseId=${it.glucoseId}, time=${it.timeInMillis}"
@@ -892,6 +964,4 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
         }
     }
 
-
-}
-
+}