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

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

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