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

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,12 +74,15 @@ 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
         prefsHelper = SharedPreferencesLibraryUtil(mReactContext)
@@ -107,8 +115,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 +126,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 +196,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 +211,6 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                                 )
                             }
                         } else {
-                            Log.d("pocDevice logsss", "Data null")
-
                             postEventDataToAPI(
                                 pocDevice,
                                 DeviceStatus.TRANSMITTER_DISCONNECT.id,
@@ -231,65 +230,100 @@ 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 {
+        debounceJob?.cancel()
+
+
+        debounceJob = apiScope.launch {
+            delay(500)
+
             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")
+                Log.d("Device event Status", "Device event Status: $status")
 
-                if (status.isNotEmpty()) {
-                    if (status != lastDeviceStatus) {
+                if (status == DeviceStatus.DISCONNECTED.id && !isDebounceTimerActive) {
+                    // Start debounce timer for 1 minutes
+                    debounceDeviceTimer = Timer()
+                    isDebounceTimerActive = true
 
-                        lastDeviceStatus = status
-                        Log.d("postEventDataToAPI: ", "Device Event Status API==> $status")
+                    debounceDeviceTimer?.schedule(object : TimerTask() {
+                        override fun run() {
+                            isDebounceTimerActive = false
 
-                        val rawData = JSONObject().apply {
-                            put("transmitterName", device?.name ?: "")
-                            put("SensorId", sensorId ?: "")
-                            put("Sensor", sensorId ?: "")
-                            put("timeInMillis", System.currentTimeMillis())
+                            callEventAPI(device, status, sensorId)
                         }
 
-                        val obj = JSONObject().apply {
-                            put("sensorId", sensorId ?: "")
-                            put("status", status)
-                            put("rawData", rawData)
-                        }
+                    }, 1 * 60 * 1000) // 1 minutes in milliseconds
 
-                        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 started for disconnection reminder")
+                } else {
+                    // Either device is not disconnected or timer already running
+                    debounceDeviceTimer?.cancel()
+                    debounceDeviceTimer = null
+                    isDebounceTimerActive = false
 
-                        resetDebounceTimer()
-                    }
+                    Log.d("Debounce", "Timer cancelled, event triggered immediately")
+
+                    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 Status 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 +394,10 @@ 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 +409,39 @@ 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 +570,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,11 +585,20 @@ 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 (lastSyncData != null) {
+                if (prefsHelper.lastSyncData != null) {
+                    dataAge = currentTime - prefsHelper.lastSyncData.timeInMillis
+                }
+
+                if (lastSyncData != null && dataAge > 3 * 60 * 1000L) {
+                     isBatchProcessing = true
                     CoroutineScope(Dispatchers.IO).launch {
-                        val glucoseData = mModel.getGlucoseBetweenTime(lastSyncData.lastSyncTime)
+                       
+                        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())
@@ -541,16 +610,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 +644,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 +663,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 +693,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 +837,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 +880,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 +972,4 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
         }
     }
 
-
-}
-
+}

package/android/src/main/java/com/mytatvarnsdk/activity/SearchTransmitterActivity.kt

@@ -272,8 +272,8 @@ class SearchTransmitterActivity : BaseBleActivity() {
         binding.tvTransName.text = "Sno: ${transmitterDeviceInfo!!.pocDevice.name}"
         val formatter = SimpleDateFormat("hh:mm a", Locale.getDefault())
         binding.tvDateTime.text = "Connected on ${formatter.format(Date()).uppercase()}"
-        binding.clSuccess.visibility = View.VISIBLE
         binding.clMain.visibility = View.GONE
+        binding.clSuccess.visibility = View.VISIBLE
         binding.commonButton.btnProceed.isEnabled = true
         binding.commonButton.btnProceed.alpha = 1.0f
         binding.view2.background = ContextCompat.getDrawable(this, R.drawable.bg_green_progress)

package/android/src/main/java/com/mytatvarnsdk/activity/VideoActivity.kt

@@ -46,6 +46,9 @@ class VideoActivity : AppCompatActivity() {
             .build()
         binding.youtubePlayerView.enableAutomaticInitialization = false
 
+        binding.ivClose.setOnClickListener {
+            handleBackPressedManually()
+        }
 
         binding.youtubePlayerView.addFullscreenListener(object : FullscreenListener {
             override fun onEnterFullscreen(fullscreenView: View, exitFullscreen: () -> Unit) {
@@ -83,12 +86,15 @@ class VideoActivity : AppCompatActivity() {
 
     private val onBackPressedCallback = object : OnBackPressedCallback(true) {
         override fun handleOnBackPressed() {
-            if (isFullscreen) {
-                // if the player is in fullscreen, exit fullscreen
-                youTubePlayer.toggleFullscreen()
-            } else {
-                finish()
-            }
+            handleBackPressedManually()
+        }
+    }
+
+    private fun handleBackPressedManually() {
+        if (isFullscreen) {
+            youTubePlayer.toggleFullscreen()
+        } else {
+            finish()
         }
     }
 }

package/android/src/main/res/layout/activity_video.xml

@@ -8,6 +8,15 @@
     android:background="#E6000000"
     tools:context=".activity.VideoActivity">
 
+    <androidx.appcompat.widget.AppCompatImageView
+        android:id="@+id/ivClose"
+        android:layout_width="40dp"
+        android:layout_height="40dp"
+        android:padding="7dp"
+        app:layout_constraintStart_toStartOf="parent"
+        app:layout_constraintTop_toTopOf="parent"
+        app:srcCompat="@drawable/ic_close_gray" />
+
     <com.pierfrancescosoffritti.androidyoutubeplayer.core.player.views.YouTubePlayerView
         android:id="@+id/youtube_player_view"
         android:layout_width="match_parent"
@@ -23,10 +32,12 @@
         android:id="@+id/full_screen_view_container"
         android:layout_width="match_parent"
         android:layout_height="match_parent"
-        android:visibility="gone"
+        android:visibility="visible"
         app:layout_constraintBottom_toBottomOf="parent"
         app:layout_constraintEnd_toEndOf="parent"
         app:layout_constraintStart_toStartOf="parent"
-        app:layout_constraintTop_toTopOf="parent" />
+        app:layout_constraintTop_toTopOf="parent">
+
+    </FrameLayout>
 
 </androidx.constraintlayout.widget.ConstraintLayout>

package/package.json

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