react-native-mytatva-rn-sdk 1.2.51 → 1.2.53

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

@@ -21,6 +21,7 @@ import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.CatalystInstance
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.mytatvarnsdk.CgmTrackyLibModule
 import com.mytatvarnsdk.R
 import com.mytatvarnsdk.databinding.ActivitySensorConnectSuccessBinding
 import com.mytatvarnsdk.databinding.ExitDialogBottomsheetBinding
@@ -34,7 +35,6 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
 import org.json.JSONObject
-import com.mytatvarnsdk.CgmTrackyLibModule
 import java.text.SimpleDateFormat
 import java.util.Date
 import java.util.Locale
@@ -80,15 +80,18 @@ class SensorConnectSuccessActivity : AppCompatActivity() {
         binding.toolbar.btnWhatsapp.setOnClickListener {
             startActivity(
                 Intent(this, HelpActivity::class.java)
-                    .putExtra("ScreenName", "Sensor Screen")
+                    .putExtra("ScreenName", "Sensor page")
             )
         }
 
         binding.toolbar.btnWatchDemo.setOnClickListener {
-            sendDataToRN("","cgm_watch_demo_clicked")
+            sendDataToRN("", "cgm_watch_demo_clicked")
 
             startActivity(
-                Intent(this, VideoActivity::class.java).putExtra("VideoId", if (isForReconnect) "n_pUrFoZ1wQ" else "r5Zemc4R044")
+                Intent(this, VideoActivity::class.java).putExtra(
+                    "VideoId",
+                    if (isForReconnect) "n_pUrFoZ1wQ" else "r5Zemc4R044"
+                )
             )
         }
 
@@ -171,7 +174,7 @@ class SensorConnectSuccessActivity : AppCompatActivity() {
         obj.put("rawData", rawData)
 
         authenticateSDKService.postDeviceData(
-            environment = TATVA_ENVIRONMENT.PROD,
+            environment = if (CgmTrackyLibModule.env.lowercase() == "uat") TATVA_ENVIRONMENT.STAGE else TATVA_ENVIRONMENT.PROD,
             data = obj.toString(),
             token = CgmTrackyLibModule.userToken,
             loaderListener = object : LoaderListener {

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

@@ -92,7 +92,7 @@ class StartCGMActivity : AppCompatActivity() {
         binding.toolbar.btnWhatsapp.setOnClickListener {
             startActivity(
                 Intent(this, HelpActivity::class.java)
-                    .putExtra("ScreenName", "Start CGM Screen")
+                    .putExtra("ScreenName", "connection journey page")
             )
         }
 

package/android/src/main/java/com/mytatvarnsdk/model/BaseViewModel.java

@@ -8,7 +8,6 @@ import androidx.lifecycle.LiveData;
 import androidx.lifecycle.MediatorLiveData;
 import androidx.lifecycle.Transformations;
 
-import java.util.Date;
 import java.util.List;
 
 import cgmblelib.database.entity.PocDevice;
@@ -22,88 +21,93 @@ import cgmblelib.database.repository.RepositoryGlucose;
  * @author minyuchun
  */
 public class BaseViewModel extends AndroidViewModel {
-  /**
-   * 设备信息储存库
-   */
-  private RepositoryDevice mRepositoryDevice;
-  /**
-   * 血糖信息储存库
-   */
-  private RepositoryGlucose mRepositoryGlucose;
-  /**
-   * 最新的设备(数据库中最大Id的设备，无论是绑定还是非绑定)
-   */
-  private LiveData<PocDevice> mDevice;
-  /**
-   * 血糖数据集列表持久化
-   */
-  private LiveData<List<PocGlucose>> mGlucoseList;
-  /**
-   * 最新的血糖数据持久化，当发射器绑定时，获取最新的，若发射器解除绑定则无
-   */
-  private LiveData<PocGlucose> mLatestGlucose;
-  /***
-   * 设备是否绑定
-   */
-  private MediatorLiveData<Integer> mBindDeviceId = new MediatorLiveData<>();
-
-  public BaseViewModel(@NonNull Application application) {
-    super(application);
-    mRepositoryDevice = RepositoryDevice.getInstance(application);
-    mRepositoryGlucose = RepositoryGlucose.getInstance(application);
-    mDevice = mRepositoryDevice.getLiveDataLatestDeviceIoThread();
-    mBindDeviceId.addSource(mDevice, device -> {
-      if (device != null && device.isBound()) {
-        if (mBindDeviceId.getValue() == null || mBindDeviceId.getValue() != device.getId()) {
-          mBindDeviceId.setValue(device.getId());
-        }
-      } else {
-        mBindDeviceId.setValue(0);
-      }
-    });
-    LoadGlucose();
-  }
-
-  /**
-   * 获取持久化设备数据,获取最新的设备的所有信息
-   */
-  public synchronized LiveData<PocDevice> getDevice() {
-    return mDevice;
-  }
-
-  public synchronized LiveData<List<PocGlucose>> getAllGlucose() {
-    return mGlucoseList;
-  }
-
-  public synchronized LiveData<PocGlucose> getLatestGlucose() {
-    return mLatestGlucose;
-  }
-
-  /**
-   * 获取血糖数据
-   */
-  private synchronized void LoadGlucose() {
-    mGlucoseList = Transformations.switchMap(mBindDeviceId, input -> mRepositoryGlucose.getLiveDataGlucoseListByDeviceId(input));
-    mLatestGlucose = Transformations.map(mGlucoseList, input -> {
-      if (input != null && input.size() > 0) {
-        return input.get(input.size() - 1);
-      } else {
-        return null;
-      }
-    });
-  }
-
-
-  public List<PocGlucose> getGlucoseByTime() {
-    return mRepositoryGlucose.getGlucoseByDeviceIdAndTimeMillis(7, 1748005587474L);
-  }
-
-  public List<PocGlucose> getGlucoseBetweenTime(long startTime) {
-    return mRepositoryGlucose.getGlucoseByTimeMillis(startTime, System.currentTimeMillis());
-  }
-
-  public PocDevice getDeviceInfo(int deviceId) {
-    return mRepositoryDevice.getDeviceByIdIoThread(deviceId);
-  }
+    /**
+     * 设备信息储存库
+     */
+    private RepositoryDevice mRepositoryDevice;
+    /**
+     * 血糖信息储存库
+     */
+    private RepositoryGlucose mRepositoryGlucose;
+    /**
+     * 最新的设备(数据库中最大Id的设备，无论是绑定还是非绑定)
+     */
+    private LiveData<PocDevice> mDevice;
+    /**
+     * 血糖数据集列表持久化
+     */
+    private LiveData<List<PocGlucose>> mGlucoseList;
+    /**
+     * 最新的血糖数据持久化，当发射器绑定时，获取最新的，若发射器解除绑定则无
+     */
+    private LiveData<PocGlucose> mLatestGlucose;
+    /***
+     * 设备是否绑定
+     */
+    private MediatorLiveData<Integer> mBindDeviceId = new MediatorLiveData<>();
+
+    public BaseViewModel(@NonNull Application application) {
+        super(application);
+        mRepositoryDevice = RepositoryDevice.getInstance(application);
+        mRepositoryGlucose = RepositoryGlucose.getInstance(application);
+        mDevice = mRepositoryDevice.getLiveDataLatestDeviceIoThread();
+        mBindDeviceId.addSource(mDevice, device -> {
+            if (device != null && device.isBound()) {
+                if (mBindDeviceId.getValue() == null || mBindDeviceId.getValue() != device.getId()) {
+                    mBindDeviceId.setValue(device.getId());
+                }
+            } else {
+                mBindDeviceId.setValue(0);
+            }
+        });
+        LoadGlucose();
+    }
+
+    /**
+     * 获取持久化设备数据,获取最新的设备的所有信息
+     */
+    public synchronized LiveData<PocDevice> getDevice() {
+        return mDevice;
+    }
+
+    public synchronized LiveData<List<PocGlucose>> getAllGlucose() {
+        return mGlucoseList;
+    }
+
+    public synchronized LiveData<PocGlucose> getLatestGlucose() {
+        return mLatestGlucose;
+    }
+
+    /**
+     * 获取血糖数据
+     */
+    private synchronized void LoadGlucose() {
+        mGlucoseList = Transformations.switchMap(mBindDeviceId, input -> mRepositoryGlucose.getLiveDataGlucoseListByDeviceId(input));
+        mLatestGlucose = Transformations.map(mGlucoseList, input -> {
+            if (input != null && input.size() > 0) {
+                return input.get(input.size() - 1);
+            } else {
+                return null;
+            }
+        });
+    }
+
+
+    public List<PocGlucose> getGlucoseByTime() {
+        return mRepositoryGlucose.getGlucoseByDeviceIdAndTimeMillis(7, 1748005587474L);
+    }
+
+    public List<PocGlucose> getGlucoseBetweenTime(long startTime) {
+        return mRepositoryGlucose.getGlucoseByTimeMillis(startTime, System.currentTimeMillis());
+    }
+
+    public PocDevice getDeviceInfo(int deviceId) {
+        return mRepositoryDevice.getDeviceByIdIoThread(deviceId);
+    }
+
+    public void clearAllGlucoseAndDeviceData() {
+        mRepositoryGlucose.deleteAllGlucoseData();
+        mRepositoryDevice.deleteAllDeviceData();
+    }
 
 }

package/android/src/main/java/com/mytatvarnsdk/network/AuthenticateSDKService.kt

@@ -23,207 +23,207 @@ import okhttp3.RequestBody.Companion.toRequestBody
 class AuthenticateSDKService(val scope: CoroutineScope) {
 
 
-  fun postCGMData(
-    environment: TATVA_ENVIRONMENT,
-    data: String,
-    token: String,
-    responseListener: ResponseListener
-  ) {
-    scope.launch {
-      try {
-
-        val apiServiceInterface = RetrofitInstance.getRetroInstance().create(
-          ApiServiceInterface::class.java
-        )
-
-        val encryptionKey = getEncryptionKey(
-          env = TATVA_ENVIRONMENT.PROD,
-          prodEncKey = PROD_ENC_KEY,
-          stagEncKey = STAGE_ENC_KEY
-        )
-
-        val encryptionIv = getEncryptionIv(
-          env = TATVA_ENVIRONMENT.PROD, prodEncIv = PROD_ENC_IV, stagEncIv = STAGE_ENC_IV
-        )
-
-        Log.d("API Response", "data: $data")
-
-        val encryptedString = getEncryptedText(
-          data = data,
-          encryptionKey = encryptionKey,
-          encryptionIv = encryptionIv
-        )
-
-        Log.d("API Response", "encryptedString: $encryptedString")
-
-        val decryptedString = getDecryptedData(
-          cipherText = encryptedString,
-          encryptionKey = encryptionKey,
-          encryptionIv = encryptionIv
-        )
-
-        Log.d("API Response", "decryptedString: $decryptedString")
-
-        val headers = mapOf(
-          "api-key" to if (environment == TATVA_ENVIRONMENT.PROD) PROD_API_KEY else STAGE_API_KEY,
-          "token" to token,
-          "Content-Type" to "text/plain"
-        )
-
-        val url =
-          "${if (environment == TATVA_ENVIRONMENT.PROD) PROD_BASE_URL else STAGE_BASE_URL}/cgm/logs"
-
-        val requestBody = encryptedString.toRequestBody("text/plain".toMediaType())
-
-        val response = apiServiceInterface.postCgmLogs(url, headers, requestBody).string()
-
-        val decryptedResponse = getDecryptedData(
-          cipherText = response.toString(),
-          encryptionKey = encryptionKey,
-          encryptionIv = encryptionIv
-        )
-
-        Log.d("API Response", "API response: $decryptedResponse")
-
-        responseListener.onResponseSuccess(response)
-      } catch (e: Exception) {
-        responseListener.onResponseFail()
-        e.printStackTrace()
-        Log.d("API Response", "Exception: ${e.message}")
-      }
+    fun postCGMData(
+        environment: TATVA_ENVIRONMENT,
+        data: String,
+        token: String,
+        responseListener: ResponseListener
+    ) {
+        scope.launch {
+            try {
+
+                val apiServiceInterface = RetrofitInstance.getRetroInstance().create(
+                    ApiServiceInterface::class.java
+                )
+
+                val encryptionKey = getEncryptionKey(
+                    env = TATVA_ENVIRONMENT.PROD,
+                    prodEncKey = PROD_ENC_KEY,
+                    stagEncKey = STAGE_ENC_KEY
+                )
+
+                val encryptionIv = getEncryptionIv(
+                    env = TATVA_ENVIRONMENT.PROD, prodEncIv = PROD_ENC_IV, stagEncIv = STAGE_ENC_IV
+                )
+
+                Log.d("API Response", "data: $data")
+
+                val encryptedString = getEncryptedText(
+                    data = data,
+                    encryptionKey = encryptionKey,
+                    encryptionIv = encryptionIv
+                )
+
+                Log.d("API Response", "encryptedString: $encryptedString")
+
+                val decryptedString = getDecryptedData(
+                    cipherText = encryptedString,
+                    encryptionKey = encryptionKey,
+                    encryptionIv = encryptionIv
+                )
+
+                Log.d("API Response", "decryptedString: $decryptedString")
+
+                val headers = mapOf(
+                    "api-key" to if (environment == TATVA_ENVIRONMENT.PROD) PROD_API_KEY else STAGE_API_KEY,
+                    "token" to token,
+                    "Content-Type" to "text/plain"
+                )
+
+                val url =
+                    "${if (environment == TATVA_ENVIRONMENT.PROD) PROD_BASE_URL else STAGE_BASE_URL}/cgm/logs"
+
+                val requestBody = encryptedString.toRequestBody("text/plain".toMediaType())
+
+                val response = apiServiceInterface.postCgmLogs(url, headers, requestBody).string()
+
+                val decryptedResponse = getDecryptedData(
+                    cipherText = response.toString(),
+                    encryptionKey = encryptionKey,
+                    encryptionIv = encryptionIv
+                )
+
+                Log.d("API Response", "API response: $decryptedResponse")
+
+                responseListener.onResponseSuccess(response)
+            } catch (e: Exception) {
+                responseListener.onResponseFail()
+                e.printStackTrace()
+                Log.d("API Response", "Exception: ${e.message}")
+            }
+        }
     }
-  }
-
-
-  fun postDeviceData(
-    environment: TATVA_ENVIRONMENT,
-    data: String,
-    token: String,
-    loaderListener: LoaderListener
-  ) {
-    scope.launch {
-      try {
-        loaderListener.onShowLoader()
-
-        val apiServiceInterface = RetrofitInstance.getRetroInstance().create(
-          ApiServiceInterface::class.java
-        )
-
-        val encryptionKey = getEncryptionKey(
-          env = TATVA_ENVIRONMENT.PROD,
-          prodEncKey = PROD_ENC_KEY,
-          stagEncKey = STAGE_ENC_KEY
-        )
-
-        val encryptionIv = getEncryptionIv(
-          env = TATVA_ENVIRONMENT.PROD, prodEncIv = PROD_ENC_IV, stagEncIv = STAGE_ENC_IV
-        )
-
-        Log.d("API Response", "data: $data")
-
-        val encryptedString = getEncryptedText(
-          data = data,
-          encryptionKey = encryptionKey,
-          encryptionIv = encryptionIv
-        )
-
-        Log.d("API Response", "encryptedString: $encryptedString")
-
-        val decryptedString = getDecryptedData(
-          cipherText = encryptedString,
-          encryptionKey = encryptionKey,
-          encryptionIv = encryptionIv
-        )
-
-        Log.d("API Response", "decryptedString: $decryptedString")
-
-        val headers = mapOf(
-          "api-key" to if (environment == TATVA_ENVIRONMENT.PROD) PROD_API_KEY else STAGE_API_KEY,
-          "token" to token,
-          "Content-Type" to "text/plain"
-        )
-
-        val url =
-          "${if (environment == TATVA_ENVIRONMENT.PROD) PROD_BASE_URL else STAGE_BASE_URL}/cgm/connection"
-
-        val requestBody = encryptedString.toRequestBody("text/plain".toMediaType())
-
-        val response = apiServiceInterface.postCgmLogs(url, headers, requestBody).string()
-
-        val decryptedResponse = getDecryptedData(
-          cipherText = response.toString(),
-          encryptionKey = encryptionKey,
-          encryptionIv = encryptionIv
-        )
-
-        Log.d("API Response", "API response: $decryptedResponse")
-
-      } catch (e: Exception) {
-        e.printStackTrace()
-        Log.d("API Response", "Exception: ${e.message}")
-      } finally {
-        loaderListener.onHideLoader()
-      }
+
+
+    fun postDeviceData(
+        environment: TATVA_ENVIRONMENT,
+        data: String,
+        token: String,
+        loaderListener: LoaderListener
+    ) {
+        scope.launch {
+            try {
+                loaderListener.onShowLoader()
+
+                val apiServiceInterface = RetrofitInstance.getRetroInstance().create(
+                    ApiServiceInterface::class.java
+                )
+
+                val encryptionKey = getEncryptionKey(
+                    env = TATVA_ENVIRONMENT.PROD,
+                    prodEncKey = PROD_ENC_KEY,
+                    stagEncKey = STAGE_ENC_KEY
+                )
+
+                val encryptionIv = getEncryptionIv(
+                    env = TATVA_ENVIRONMENT.PROD, prodEncIv = PROD_ENC_IV, stagEncIv = STAGE_ENC_IV
+                )
+
+                Log.d("API Response", "data: $data")
+
+                val encryptedString = getEncryptedText(
+                    data = data,
+                    encryptionKey = encryptionKey,
+                    encryptionIv = encryptionIv
+                )
+
+                Log.d("API Response", "encryptedString: $encryptedString")
+
+                val decryptedString = getDecryptedData(
+                    cipherText = encryptedString,
+                    encryptionKey = encryptionKey,
+                    encryptionIv = encryptionIv
+                )
+
+                Log.d("API Response", "decryptedString: $decryptedString")
+
+                val headers = mapOf(
+                    "api-key" to if (environment == TATVA_ENVIRONMENT.PROD) PROD_API_KEY else STAGE_API_KEY,
+                    "token" to token,
+                    "Content-Type" to "text/plain"
+                )
+
+                val url =
+                    "${if (environment == TATVA_ENVIRONMENT.PROD) PROD_BASE_URL else STAGE_BASE_URL}/cgm/connection"
+
+                val requestBody = encryptedString.toRequestBody("text/plain".toMediaType())
+
+                val response = apiServiceInterface.postCgmLogs(url, headers, requestBody).string()
+
+                val decryptedResponse = getDecryptedData(
+                    cipherText = response.toString(),
+                    encryptionKey = encryptionKey,
+                    encryptionIv = encryptionIv
+                )
+
+                Log.d("API Response", "API response: $decryptedResponse")
+
+            } catch (e: Exception) {
+                e.printStackTrace()
+                Log.d("API Response", "Exception: ${e.message}")
+            } finally {
+                loaderListener.onHideLoader()
+            }
+        }
     }
-  }
-
-  fun getCGMData(
-    environment: TATVA_ENVIRONMENT,
-    token: String,
-    responseListener: ResponseListener
-  ) {
-    scope.launch {
-      try {
-
-        val apiServiceInterface = RetrofitInstance.getRetroInstance().create(
-          ApiServiceInterface::class.java
-        )
-
-        val encryptionKey = getEncryptionKey(
-          env = TATVA_ENVIRONMENT.PROD,
-          prodEncKey = PROD_ENC_KEY,
-          stagEncKey = STAGE_ENC_KEY
-        )
-
-        val encryptionIv = getEncryptionIv(
-          env = TATVA_ENVIRONMENT.PROD, prodEncIv = PROD_ENC_IV, stagEncIv = STAGE_ENC_IV
-        )
-
-        val headers = mapOf(
-          "api-key" to if (environment == TATVA_ENVIRONMENT.PROD) PROD_API_KEY else STAGE_API_KEY,
-          "token" to token
-        )
-
-        val url =
-          "${if (environment == TATVA_ENVIRONMENT.PROD) PROD_BASE_URL else STAGE_BASE_URL}/cgm/status"
-
-        val response = apiServiceInterface.getCgmStatus(url, headers).string()
-
-        val decryptedResponse = getDecryptedData(
-          cipherText = response.toString(),
-          encryptionKey = encryptionKey,
-          encryptionIv = encryptionIv
-        )
-
-        Log.d("API Response", "API Response: $decryptedResponse")
-
-        responseListener.onResponseSuccess(decryptedResponse)
-      } catch (e: Exception) {
-        responseListener.onResponseFail()
-        e.printStackTrace()
-        Log.d("API Response", "Exception: ${e.message}")
-      }
+
+    fun getCGMData(
+        environment: TATVA_ENVIRONMENT,
+        token: String,
+        responseListener: ResponseListener
+    ) {
+        scope.launch {
+            try {
+
+                val apiServiceInterface = RetrofitInstance.getRetroInstance().create(
+                    ApiServiceInterface::class.java
+                )
+
+                val encryptionKey = getEncryptionKey(
+                    env = TATVA_ENVIRONMENT.PROD,
+                    prodEncKey = PROD_ENC_KEY,
+                    stagEncKey = STAGE_ENC_KEY
+                )
+
+                val encryptionIv = getEncryptionIv(
+                    env = TATVA_ENVIRONMENT.PROD, prodEncIv = PROD_ENC_IV, stagEncIv = STAGE_ENC_IV
+                )
+
+                val headers = mapOf(
+                    "api-key" to if (environment == TATVA_ENVIRONMENT.PROD) PROD_API_KEY else STAGE_API_KEY,
+                    "token" to token
+                )
+
+                val url =
+                    "${if (environment == TATVA_ENVIRONMENT.PROD) PROD_BASE_URL else STAGE_BASE_URL}/cgm/status"
+
+                val response = apiServiceInterface.getCgmStatus(url, headers).string()
+
+                val decryptedResponse = getDecryptedData(
+                    cipherText = response.toString(),
+                    encryptionKey = encryptionKey,
+                    encryptionIv = encryptionIv
+                )
+
+                Log.d("API Response", "API Response: $decryptedResponse")
+
+                responseListener.onResponseSuccess(decryptedResponse)
+            } catch (e: Exception) {
+                responseListener.onResponseFail()
+                e.printStackTrace()
+                Log.d("API Response", "Exception: ${e.message}")
+            }
+        }
     }
-  }
 
-  interface LoaderListener {
-    fun onShowLoader()
-    fun onHideLoader()
-  }
+    interface LoaderListener {
+        fun onShowLoader()
+        fun onHideLoader()
+    }
 
-  interface ResponseListener {
-    fun onResponseSuccess(response: String)
-    fun onResponseFail()
-  }
+    interface ResponseListener {
+        fun onResponseSuccess(response: String)
+        fun onResponseFail()
+    }
 
 }

package/android/src/main/java/com/mytatvarnsdk/utils/TatvaEncryptionConfig.kt

@@ -1,7 +1,7 @@
 package com.mytatvarnsdk.utils
 
 object TatvaEncryptionConfig {
-    const val STAGE_BASE_URL = "https://api-feature2.mytatva.in/api/v8"
+    const val STAGE_BASE_URL = "https://api-uat.mytatva.in/api/v8"
     const val PROD_BASE_URL = "https://api.mytatva.in/api/v8"
 
     const val PROD_ENC_KEY = "9Ddyaf6rfywpiTvTiax2iq6ykKpaxgJ6"