react-native-mytatva-rn-sdk 1.2.4 → 1.2.5

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

@@ -0,0 +1,885 @@
+package com.mytatvarnsdk
+
+import android.app.Application
+import android.bluetooth.BluetoothAdapter
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import androidx.core.content.ContextCompat
+import androidx.lifecycle.Observer
+import androidx.lifecycle.ViewModelProvider
+import androidx.lifecycle.ViewModelStore
+import cgmblelib.Enum.enumError
+import cgmblelib.database.entity.PocDevice
+import cgmblelib.database.entity.PocGlucose
+import cgmblelib.utils.SharedPreferencesLibraryUtil
+import cgmblelib.utils.SyncMeta
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.google.gson.Gson
+import com.google.gson.GsonBuilder
+import com.mytatvarnsdk.activity.HelpActivity
+import com.mytatvarnsdk.activity.PermissionActivity
+import com.mytatvarnsdk.activity.PermissionUtils
+import com.mytatvarnsdk.activity.SearchTransmitterActivity
+import com.mytatvarnsdk.activity.StartCGMActivity
+import com.mytatvarnsdk.model.AllCGMLogRequest
+import com.mytatvarnsdk.model.CgmLog
+import com.mytatvarnsdk.model.GlucoseLog
+import com.mytatvarnsdk.model.GlucoseLog.ErrorObject
+import com.mytatvarnsdk.model.GlucoseLog.GlucoseStatusObject
+import com.mytatvarnsdk.model.GlucoseLog.TrendObject
+import com.mytatvarnsdk.model.GlucoseLogRequest
+import com.mytatvarnsdk.model.MainActivityModel
+import com.mytatvarnsdk.network.AuthenticateSDKService
+import com.mytatvarnsdk.network.AuthenticateSDKService.LoaderListener
+import com.mytatvarnsdk.utils.DeviceStatus
+import com.mytatvarnsdk.utils.TATVA_ENVIRONMENT
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import org.json.JSONObject
+import java.util.Date
+import kotlin.coroutines.resume
+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, "")
+            resetDebounceTimer()
+          }
+
+          if (device != null) {
+            Log.d("observeDeviceStatus: ", device.toString())
+          }
+        }
+      }
+    } catch (e: Exception) {
+      Log.e("observeDeviceStatus", "observeDeviceStatus: ${e.message}")
+    }
+  }
+
+  private fun postEventDataToAPI(device: PocDevice, mStatus: String) {
+    apiScope.launch {
+      try {
+        val bluetoothAdapter: BluetoothAdapter? = BluetoothAdapter.getDefaultAdapter()
+        var bleStatus = bluetoothAdapter?.isEnabled == true
+        var status = ""
+
+        if (mStatus.isEmpty()) {
+          if (device.isBoundAndConnect) {
+            status = DeviceStatus.CONNECTED.id
+          } else if (device.isBoundButDisConnect) {
+            status = DeviceStatus.TRANSMITTER_DISCONNECT.id
+          } else if (device.isDisConnect) {
+            status = if (!bleStatus) {
+              DeviceStatus.BLUETOOTH_OFF.id
+            } else {
+              DeviceStatus.DISCONNECTED.id
+            }
+          } else if (device.isUnBind) {
+            status = DeviceStatus.TRANSMITTER_DISCONNECT_BOX.id
+          }
+        } else {
+          status = mStatus
+        }
+
+        if (status.isNotEmpty()) {
+          val rawData = JSONObject()
+          rawData.put("transmitterName", device.name)
+          rawData.put("SensorId", device.qrMessage)
+          rawData.put("Sensor", device.qrMessage)
+          rawData.put("timeInMillis", Date().time)
+
+          val obj = JSONObject()
+          obj.put("sensorId", device.qrMessage)
+          obj.put("status", status)
+          obj.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()
+      }
+    }
+  }
+
+  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 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}")
+    }
+  }
+
+  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 location permissions
+    requiredPermissions.addAll(PermissionUtils.LOCAL_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
+      Handler(Looper.getMainLooper()).post {
+        //Observe latest glucose data
+        mModel.latestGlucose.observeForever { pocGlucose ->
+          if (pocGlucose != null) {
+
+            if (pocGlucose.errorCode == enumError.NONE) {
+              if (pocGlucose.showGlucoseMG > 0) {
+                val dto: GlucoseLog = mapToDto(pocGlucose)
+                val logs: ArrayList<GlucoseLog> = ArrayList()
+                logs.add(dto)
+
+                val request: GlucoseLogRequest =
+                  GlucoseLogRequest(vendor = "GoodFlip", logs = logs)
+                val gson: Gson = GsonBuilder().create()
+                val json = gson.toJson(request)
+
+                Log.d("Glucose data 3 min==> ", "Glucose data 3 min==> final Json: $json")
+
+                authenticateSDKService.postCGMData(
+                  environment = if ("uat".uppercase() == "PROD") TATVA_ENVIRONMENT.PROD else TATVA_ENVIRONMENT.STAGE,
+                  data = json.toString(),
+                  token = userToken,
+                  responseListener = object :
+                    AuthenticateSDKService.ResponseListener {
+                    override fun onResponseSuccess() {
+                    }
+
+                    override fun onResponseFail() {
+                    }
+                  }
+                )
+              }
+            } else {
+              if (pocGlucose.errorCode == enumError.ERROR_FLOODING_WATER) {
+                lastDeviceStatus =
+                  pocGlucose.deviceId.toInt().let { mModel.getDeviceInfo(it) }
+                lastDeviceStatus?.let {
+                  postEventDataToAPI(
+                    it,
+                    DeviceStatus.MOISTURE_DETECT.id
+                  )
+                }
+                resetDebounceTimer()
+              } else if (pocGlucose.errorCode == enumError.ERROR_CURRENT_SMALL || pocGlucose.errorCode == enumError.ERROR_NOISE || pocGlucose.errorCode == enumError.ERROR_SENSITIVITY_ATTENUATION) {
+                lastDeviceStatus =
+                  pocGlucose.deviceId.toInt().let { mModel.getDeviceInfo(it) }
+                lastDeviceStatus?.let {
+                  postEventDataToAPI(
+                    it,
+                    DeviceStatus.WEAK_SIGNAL.id
+                  )
+                }
+                resetDebounceTimer()
+              } else {
+                lastDeviceStatus =
+                  pocGlucose.deviceId.toInt().let { mModel.getDeviceInfo(it) }
+                lastDeviceStatus?.let {
+                  postEventDataToAPI(
+                    it,
+                    DeviceStatus.ERROR_COMMON.id
+                  )
+                }
+                resetDebounceTimer()
+              }
+            }
+          }
+        }
+      }
+    } catch (e: Exception) {
+      Log.e("observeGlucoseData", "observeGlucoseData: ${e.message}")
+    }
+  }*/
+
+  @ReactMethod
+  fun observeGlucoseData(token: String) {
+    try {
+      userToken = token
+
+      // Remove existing observer if any to prevent memory leaks
+      stopObservingGlucoseData()
+
+      // Create new observer with explicit nullable parameter type
+      glucoseObserver = Observer<PocGlucose?> { pocGlucose ->
+        // Critical fix: Explicitly handle nullable parameter
+        if (pocGlucose != null) {
+          handleGlucoseData(pocGlucose)
+        } else {
+          Log.w("observeGlucoseData", "Received null glucose data - skipping processing")
+        }
+      }
+
+      // Add observer on main thread
+      Handler(Looper.getMainLooper()).post {
+        glucoseObserver?.let { observer ->
+          try {
+            mModel.latestGlucose.observeForever(observer)
+            isObserving = true
+            Log.d("observeGlucoseData", "Observer added successfully")
+          } catch (e: Exception) {
+            Log.e("observeGlucoseData", "Error adding observer: ${e.message}")
+            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() {
+                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)
+      }
+    } 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
+          }
+        }
+
+        postEventDataToAPI(it, statusId)
+        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
+    Log.e("userToken", "userToken: ${userToken}")
+    try {
+      val lastSyncData = prefsHelper.lastSyncData
+      Log.d("lastSyncData: ", Gson().toJson(lastSyncData).toString())
+
+      if (lastSyncData != null) {
+        CoroutineScope(Dispatchers.IO).launch {
+          getGlucoseDataAndUploadInBatch(
+            mModel.getGlucoseBetweenTime(
+              lastSyncData.lastSyncTime
+            )
+          )
+        }
+      } else {
+        observeGlucoseData(userToken)
+      }
+
+    } catch (e: Exception) {
+      Log.e("observeAllGlucoseData", "observeAllGlucoseData Error: ${e.message}")
+    }
+  }*/
+
+
+  @ReactMethod
+  fun observeAllGlucoseData(token: String) {
+    userToken = token
+    Log.e("userToken", "userToken: $token")
+
+    // Stop current observation to prevent duplicates
+    stopObservingGlucoseData()
+
+    try {
+      val lastSyncData = prefsHelper.lastSyncData
+      Log.d("lastSyncData: ", Gson().toJson(lastSyncData).toString())
+
+      if (lastSyncData != null) {
+        CoroutineScope(Dispatchers.IO).launch {
+          val glucoseData = mModel.getGlucoseBetweenTime(lastSyncData.lastSyncTime)
+          if (glucoseData != null) {
+            getGlucoseDataAndUploadInBatch(glucoseData)
+          } else {
+            Log.d("observeAllGlucoseData", "No glucose data found, starting live observation")
+            observeGlucoseData(userToken)
+          }
+        }
+      } else {
+        observeGlucoseData(userToken)
+      }
+    } catch (e: Exception) {
+      Log.e("observeAllGlucoseData", "observeAllGlucoseData Error: ${e.message}")
+    }
+  }
+
+  @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}")
+          }
+        }
+      }
+      glucoseObserver = null
+    } catch (e: Exception) {
+      Log.e("stopObservingGlucoseData", "Error stopping observer: ${e.message}")
+    }
+  }
+
+  fun getGlucoseDataAndUploadInBatch(dataList: List<PocGlucose>) {
+    if (dataList.isEmpty()) {
+      Log.d("getGlucoseDataAndUploadInBatch", "No data to upload, starting live observation")
+      if (!isObserving) {
+        observeGlucoseData(userToken)
+      }
+      return
+    }
+
+    val batchSize = 40
+    val chunks = dataList.chunked(batchSize)
+
+    Log.d("getGlucoseDataAndUploadInBatch", "Starting batch upload with ${chunks.size} batches")
+
+    CoroutineScope(Dispatchers.IO).launch {
+      var lastSyncedRecord: PocGlucose? = null
+      var allBatchesSuccessful = true
+
+      for ((index, batch) in chunks.withIndex()) {
+        try {
+          val transformedLogs = batch.filter { it.showGlucoseMG > 0 }.map { pocGlucose ->
+            CgmLog(
+              timeInMillis = pocGlucose.timeInMillis,
+              countdownMinutes = pocGlucose.countdownMinutes,
+              countdownDays = pocGlucose.countdownDays,
+              hypoglycemiaEarlyWarnMinutes = pocGlucose.hypoglycemiaEarlyWarnMinutes,
+              showGlucoseMG = pocGlucose.showGlucoseMG,
+              glucoseId = pocGlucose.glucoseId,
+              name = pocGlucose.name,
+              bytes = pocGlucose.bytes,
+              showGlucose = pocGlucose.showGlucose,
+              Ib = pocGlucose.ib,
+              Iw = pocGlucose.iw,
+              countdownHours = pocGlucose.countdownHours,
+              T = pocGlucose.t,
+              year = pocGlucose.year,
+              month = pocGlucose.month,
+              day = pocGlucose.day,
+              hour = pocGlucose.hour,
+              minute = pocGlucose.minute,
+              trendObject = com.mytatvarnsdk.model.TrendObject(
+                trendId = pocGlucose.trend.trendId,
+                drawableId = pocGlucose.trend.drawableId,
+                widgetImg = pocGlucose.trend.widgetImg,
+                apsChangeRate = pocGlucose.trend.apsChangeRate
+              ),
+              glucoseStatusObject = com.mytatvarnsdk.model.GlucoseStatusObject(
+                statusId = pocGlucose.glucoseStatus.statusId
+              ),
+              errorObject = com.mytatvarnsdk.model.ErrorObject(
+                errorId = pocGlucose.errorCode.errorId,
+                sound = pocGlucose.errorCode.sound
+              )
+            )
+          }
+
+          if (transformedLogs.isEmpty()) {
+            Log.d("Batch Upload", "Batch $index skipped - no valid glucose readings")
+            continue
+          }
+
+          val allResult = AllCGMLogRequest(vendor = "GoodFlip", logs = transformedLogs)
+          val json = Gson().toJson(allResult)
+
+          Log.d("Batch Upload JSON", "Batch $index with ${transformedLogs.size} records")
+          logLongJson("Batch $index JSON=>>> ", json)
+
+          val uploadSuccessful = uploadBatchSynchronously(json, index)
+
+          if (uploadSuccessful) {
+            lastSyncedRecord = batch.lastOrNull()
+            updateSyncMetadata(lastSyncedRecord)
+            Log.d("Batch Upload", "✅ Batch $index uploaded successfully")
+          } else {
+            allBatchesSuccessful = false
+            Log.e("Batch Upload", "❌ Batch $index failed, stopping further uploads")
+            break
+          }
+
+          delay(500L) // Rate limiting between batches
+
+        } catch (e: Exception) {
+          Log.e("Batch Upload", "❌ Batch $index exception: ${e.message}")
+          allBatchesSuccessful = false
+          break
+        }
+      }
+
+      // Handle last synced record error status
+      lastSyncedRecord?.let { record ->
+        if (record.errorCode != enumError.NONE) {
+          handleGlucoseError(record)
+        }
+      }
+
+      Log.d("Batch Upload", "Batch upload completed. Success: $allBatchesSuccessful")
+
+      // Only start observing new data if we're not already doing so
+      if (!isObserving) {
+        observeGlucoseData(userToken)
+      }
+    }
+  }
+
+  // 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() {
+              continuation.resume(true)
+            }
+
+            override fun onResponseFail() {
+              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", "Last sync data stored: ${Gson().toJson(syncData)}")
+      } catch (e: Exception) {
+        Log.e("updateSyncMetadata", "Error updating sync metadata: ${e.message}")
+      }
+    }
+  }
+
+  /*fun getGlucoseDataAndUploadInBatch(dataList: List<PocGlucose>) {
+    if (dataList.isNotEmpty()) {
+      val batchSize = 40
+
+      val chunks = dataList.chunked(batchSize)
+
+      CoroutineScope(Dispatchers.IO).launch {
+
+        var lastSyncedRecord: PocGlucose? = null
+
+        for ((index, batch) in chunks.withIndex()) {
+          try {
+            val transformedLogs = batch.filter { it.showGlucoseMG > 0 }.map {
+              CgmLog(
+                timeInMillis = it.timeInMillis,
+                countdownMinutes = it.countdownMinutes,
+                countdownDays = it.countdownDays,
+                hypoglycemiaEarlyWarnMinutes = it.hypoglycemiaEarlyWarnMinutes,
+                showGlucoseMG = it.showGlucoseMG,
+                glucoseId = it.glucoseId,
+                name = it.name,
+                bytes = it.bytes,
+                showGlucose = it.showGlucose,
+                Ib = it.ib,
+                Iw = it.iw,
+                countdownHours = it.countdownHours,
+                T = it.t,
+                year = it.year,
+                month = it.month,
+                day = it.day,
+                hour = it.hour,
+                minute = it.minute,
+                trendObject = com.mytatvarnsdk.model.TrendObject(
+                  trendId = it.trend.trendId,
+                  drawableId = it.trend.drawableId,
+                  widgetImg = it.trend.widgetImg,
+                  apsChangeRate = it.trend.apsChangeRate
+                ),
+                glucoseStatusObject = com.mytatvarnsdk.model.GlucoseStatusObject(
+                  statusId = it.glucoseStatus.statusId
+                ),
+                errorObject = com.mytatvarnsdk.model.ErrorObject(
+                  errorId = it.errorCode.errorId,
+                  sound = it.errorCode.sound
+                )
+              )
+            }
+
+            val allResult = AllCGMLogRequest(
+              vendor = "GoodFlip",
+              logs = transformedLogs
+            )
+
+            val json = Gson().toJson(allResult)
+            logLongJson("Final JSON=>>> ", json)
+
+//            sendDataToReact(Gson().toJson(batch).toString(), "DATA_FETCH", "CGMData")
+
+            authenticateSDKService.postCGMData(
+              environment = if ("uat".uppercase() == "PROD") TATVA_ENVIRONMENT.PROD else TATVA_ENVIRONMENT.STAGE,
+              data = json.toString(),
+              token = userToken,
+              responseListener = object : AuthenticateSDKService.ResponseListener {
+                override fun onResponseSuccess() {
+                  lastSyncedRecord = batch.lastOrNull()
+
+                  lastSyncedRecord?.let {
+                    val syncData =
+                      SyncMeta(
+                        Date().time,
+                        it.timeInMillis,
+                        it.deviceId,
+                        it.glucoseId
+                      )
+                    prefsHelper.lastSyncData = syncData
+                    Log.d(
+                      "lastSyncedRecord stored:--- ",
+                      Gson().toJson(syncData).toString()
+                    )
+                  }
+                }
+
+                override fun onResponseFail() {
+                  Log.e("Batch Upload", "❌ Batch $index failed")
+                }
+              }
+            )
+
+            delay(500L)
+          } catch (e: Exception) {
+            Log.e("Batch Upload", "❌ Batch $index exception: ${e.message}")
+            break // Optional: stop further processing if exception occurs
+          }
+        }
+
+
+        if (lastSyncedRecord != null) {
+          if (lastSyncedRecord?.errorCode != enumError.NONE) {
+            if (lastSyncedRecord?.errorCode == enumError.ERROR_FLOODING_WATER) {
+              lastDeviceStatus =
+                lastSyncedRecord?.deviceId!!.toInt().let { mModel.getDeviceInfo(it) }
+              lastDeviceStatus?.let {
+                postEventDataToAPI(
+                  it,
+                  DeviceStatus.MOISTURE_DETECT.id
+                )
+              }
+              resetDebounceTimer()
+            } else if (lastSyncedRecord?.errorCode == enumError.ERROR_CURRENT_SMALL || lastSyncedRecord?.errorCode == enumError.ERROR_NOISE || lastSyncedRecord?.errorCode == enumError.ERROR_SENSITIVITY_ATTENUATION) {
+              lastDeviceStatus =
+                lastSyncedRecord?.deviceId!!.toInt().let { mModel.getDeviceInfo(it) }
+              lastDeviceStatus?.let {
+                postEventDataToAPI(
+                  it,
+                  DeviceStatus.WEAK_SIGNAL.id
+                )
+              }
+              resetDebounceTimer()
+            } else {
+              lastDeviceStatus =
+                lastSyncedRecord?.deviceId!!.toInt().let { mModel.getDeviceInfo(it) }
+              lastDeviceStatus?.let {
+                postEventDataToAPI(
+                  it,
+                  DeviceStatus.ERROR_COMMON.id
+                )
+              }
+              resetDebounceTimer()
+            }
+          }
+        }
+
+        Log.e("Batch Upload", "All data uploaded")
+
+        observeGlucoseData(userToken)
+      }
+    } else {
+      observeGlucoseData(userToken)
+    }
+  }*/
+
+  fun logLongJson(tag: String, message: String) {
+    val maxLogSize = 4000
+    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
+    }
+
+    // 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()
+    }
+  }
+
+}