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

package/android/src/main/java/cgmblelib/ble/gattcallback/EnumSynchronous.java

@@ -0,0 +1,29 @@
+package cgmblelib.ble.gattcallback;
+
+/**
+ * 进行数据同步的状态
+ * @author minyuchun
+ */
+public enum EnumSynchronous {
+    /**
+     * 同步准备
+     */
+    SYNCHRONOUS_READY,
+    /**
+     * 同步请求
+     */
+    SYNCHRONOUS_WRITE,
+    /**
+     * 同步接收
+     */
+    SYNCHRONOUS_READ,
+    /**
+     * 同步处理完成
+     */
+    SYNCHRONOUS_COMPLETE,
+    /**
+     * 同步结束
+     */
+    SYNCHRONOUS_END,
+    ;
+}

package/android/src/main/java/cgmblelib/ble/gattcallback/GattTool.java

@@ -0,0 +1,359 @@
+package cgmblelib.ble.gattcallback;
+
+
+import android.annotation.SuppressLint;
+import android.bluetooth.BluetoothDevice;
+import android.bluetooth.BluetoothManager;
+import android.bluetooth.BluetoothProfile;
+import android.content.Context;
+
+import androidx.annotation.NonNull;
+
+import java.util.Calendar;
+import java.util.Date;
+
+import cgmblelib.Enum.enumError;
+import cgmblelib.Enum.enumGlucoseStatus;
+import cgmblelib.Enum.enumTrend;
+import cgmblelib.Enum.enumUnBind;
+import cgmblelib.base.BApplication;
+import cgmblelib.ble.entity.AlgorithmCallBack;
+import cgmblelib.ble.reconnectManagament.ReconnectManagement;
+import cgmblelib.ble.scancallback.ManageScanCallback;
+import cgmblelib.custom.livedata.ManagementLiveData;
+import cgmblelib.custom.livedata.connect.EnumConnect;
+import cgmblelib.database.entity.PocDevice;
+import cgmblelib.database.entity.PocGlucose;
+import cgmblelib.database.repository.RepositoryDevice;
+import cgmblelib.database.repository.RepositoryGlucose;
+import cgmblelib.qr.QRInformation;
+import cgmblelib.utils.ConstantsLibrary;
+import cgmblelib.utils.MyLog;
+import cgmblelib.utils.SharedPreferencesLibraryUtil;
+import cgmblelib.utils.Tool;
+import io.reactivex.Observable;
+import io.reactivex.android.schedulers.AndroidSchedulers;
+import io.reactivex.schedulers.Schedulers;
+import ist.com.sdk.AlgorithmTools;
+import ist.com.sdk.CurrentGlucose;
+import ist.com.sdk.EDevice;
+import ist.com.sdk.ErrorCode;
+import ist.com.sdk.HistoryData;
+import ist.com.sdk.LatestData;
+import ist.com.sdk.ProtocolTools;
+import ist.com.sdk.Trend;
+
+/***
+ * Gatt 工具类
+ * @author minyuchun
+ */
+public class GattTool {
+
+  /**
+   * 电流进质
+   */
+  private final static float COEFFICIENT_CURRENT = 0.1f;
+
+  /**
+   * 获取byte数组的首个byte
+   *
+   * @param bytes byte数组
+   * @return 返回首个byte
+   */
+  public static byte getFirstByte(byte[] bytes) {
+    if (bytes != null && bytes.length > 0) {
+      return bytes[0];
+    }
+    return 0;
+  }
+
+  /**
+   * 算法计算 -- 需要在子子线程中进行
+   *
+   * @param pocGlucose new Glucose form transmitter
+   * @return Glucose by algorithm
+   */
+  public static AlgorithmCallBack algorithm(Context context, @NonNull PocGlucose pocGlucose, @NonNull PocDevice device) {
+    if (device.getAlgorithmVersion() < ConstantsLibrary.ALGORITHM_VERSION) {
+      return new AlgorithmCallBack(AlgorithmCallBack.ERROR_ALGORITHM, null);
+    } else {
+      if (checkGlucoseNoInDB(context, pocGlucose)) {
+        return algorithm(context, device, pocGlucose);
+      } else {
+        return new AlgorithmCallBack(AlgorithmCallBack.DATA_REPEAT, pocGlucose);
+      }
+    }
+  }
+
+  /**
+   * 验证是否数据库中无该条数据
+   *
+   * @param context    上下文
+   * @param pocGlucose 验证的数据
+   * @return 无该数据：true
+   */
+  private static boolean checkGlucoseNoInDB(Context context, PocGlucose pocGlucose) {
+    return RepositoryGlucose.getInstance(context).getGlucoseByIdIoThread(pocGlucose.getDeviceId(), pocGlucose.getGlucoseId()) == null;
+  }
+
+  /**
+   * 算法计算
+   *
+   * @param pocGlucose 血糖值
+   * @return 返回计算完成的血糖值
+   */
+  private static AlgorithmCallBack algorithm(Context context, @NonNull PocDevice device, @NonNull PocGlucose pocGlucose) {
+    try {
+      SharedPreferencesLibraryUtil sharedPreferencesLibraryUtil = new SharedPreferencesLibraryUtil(context);
+      QRInformation information = sharedPreferencesLibraryUtil.getQRInformation();
+      float k = 0;
+      float r = 0;
+      long time = Tool.getTime(pocGlucose.getYear(), pocGlucose.getMonth(), pocGlucose.getDay(), pocGlucose.getHour(), pocGlucose.getMinute()).getTimeInMillis();
+      LatestData data = new LatestData(
+        pocGlucose.getGlucoseId(), pocGlucose.getIw(), pocGlucose.getIb(), pocGlucose.getT(), 0, 0,
+        time, device.getName());
+      if (information != null) {
+        MyLog.i("getQRInformation k=" + information.toString());
+        data.setSensorInfo(information.getSensor());
+        data.setTransmitterName(device.getName());
+        k = information.getK();
+        r = information.getR();
+        data.setK0(k);
+        data.setR(r);
+      }
+      CurrentGlucose currentGlucose;
+      try {
+        currentGlucose = AlgorithmTools.getInstance().algorithmLatestGlucose(data);
+      } catch (Exception e) {
+        e.printStackTrace();
+        return new AlgorithmCallBack(AlgorithmCallBack.DATA_LOST, pocGlucose);
+      }
+      if (currentGlucose != null) {
+        if (currentGlucose.getErrorCode() == ErrorCode.ERROR_ALGORITHM_DATA) {
+          //缓存不对
+          PocGlucose firstGlucose = RepositoryGlucose.getInstance(context).getGlucoseByIdIoThread(device.getId(), 0);
+          if (firstGlucose != null) {
+            float[] Iws = RepositoryGlucose.getInstance(context).getIwsIoThread(pocGlucose.getDeviceId(), pocGlucose.getIw());
+            float[] Ibs = RepositoryGlucose.getInstance(context).getIbsIoThread(pocGlucose.getDeviceId(), pocGlucose.getIb());
+            float[] Ts = RepositoryGlucose.getInstance(context).getTsIoThread(pocGlucose.getDeviceId(), pocGlucose.getT());
+            HistoryData historyData = new HistoryData();
+            historyData.setGlucoseId(pocGlucose.getGlucoseId());
+            historyData.setIws(Iws);
+            historyData.setIbs(Ibs);
+            historyData.setTs(Ts);
+            time = Tool.getTime(firstGlucose.getYear(), firstGlucose.getMonth(), firstGlucose.getDay(), firstGlucose.getHour(), firstGlucose.getMinute()).getTimeInMillis();
+            historyData.setStartTimeMillis(time);
+            historyData.setK0(k);
+            historyData.setR(r);
+            historyData.setTransmitterName(device.getName());
+            MyLog.w("查看历史数据 " + historyData.toString());
+            try {
+              currentGlucose = AlgorithmTools.getInstance().algorithmGlucose(historyData);
+            } catch (Exception e) {
+              e.printStackTrace();
+              return new AlgorithmCallBack(AlgorithmCallBack.DATA_LOST, pocGlucose);
+            }
+            if (currentGlucose == null) {
+              return new AlgorithmCallBack(AlgorithmCallBack.DATA_LOST, pocGlucose);
+            }
+          }
+        }
+      } else {
+        return new AlgorithmCallBack(AlgorithmCallBack.DATA_LOST, pocGlucose);
+      }
+      return GattTool.setPocGlucose(pocGlucose, currentGlucose, device);
+    } catch (Exception e) {
+      e.printStackTrace();
+      MyLog.wLog("异常 " + e.getMessage());
+    }
+    return new AlgorithmCallBack(AlgorithmCallBack.DATA_LOST, pocGlucose);
+  }
+
+  /***
+   * 将解析到的血糖数据补充到值
+   * @param glucose 解析的血糖数据
+   * @param device 设备
+   * @param bytes 原始数据
+   * @return 返回正式的血糖数据
+   */
+  public static PocGlucose getPocGlucose(@NonNull ProtocolTools.Glucose glucose, @NonNull PocDevice device, @NonNull byte[] bytes, EDevice eDevice) {
+    if (glucose.getId() > 0) {
+      PocGlucose lastGlucose = RepositoryGlucose.getInstance(BApplication.getContext()).getGlucoseByIdIoThread(device.getId(), glucose.getId() - 1);
+      if (lastGlucose != null) {
+        PocGlucose pocGlucose = new PocGlucose();
+        Calendar calendar = Calendar.getInstance();
+        calendar.set(lastGlucose.getYear(), lastGlucose.getMonth() - 1, lastGlucose.getDay(), lastGlucose.getHour(), lastGlucose.getMinute());
+        calendar.add(Calendar.MINUTE, 3);
+        pocGlucose.setTimeInMillis(calendar.getTimeInMillis());
+        pocGlucose.setYear(calendar.get(Calendar.YEAR));
+        pocGlucose.setMonth(calendar.get(Calendar.MONTH) + 1);
+        pocGlucose.setDay(calendar.get(Calendar.DAY_OF_MONTH));
+        pocGlucose.setHour(calendar.get(Calendar.HOUR_OF_DAY));
+        pocGlucose.setMinute(calendar.get(Calendar.MINUTE));
+        pocGlucose.setBytes(bytes);
+        pocGlucose.setDeviceId(device.getId());
+        pocGlucose.setGlucoseId(glucose.getId());
+        pocGlucose.setIw(glucose.getIw());
+        pocGlucose.setIb(glucose.getIb());
+        pocGlucose.setT(glucose.getT());
+        return pocGlucose;
+      }
+    } else {
+      PocGlucose pocGlucose = new PocGlucose();
+      Calendar calendar = Calendar.getInstance();
+      calendar.setTime(device.getBindDate());
+      calendar.add(Calendar.MINUTE, 3);
+      pocGlucose.setTimeInMillis(calendar.getTimeInMillis());
+      pocGlucose.setYear(calendar.get(Calendar.YEAR));
+      pocGlucose.setMonth(calendar.get(Calendar.MONTH) + 1);
+      pocGlucose.setDay(calendar.get(Calendar.DAY_OF_MONTH));
+      pocGlucose.setHour(calendar.get(Calendar.HOUR_OF_DAY));
+      pocGlucose.setMinute(calendar.get(Calendar.MINUTE));
+      pocGlucose.setBytes(bytes);
+      pocGlucose.setDeviceId(device.getId());
+      pocGlucose.setGlucoseId(glucose.getId());
+      pocGlucose.setIw(glucose.getIw());
+      pocGlucose.setIb(glucose.getIb());
+      pocGlucose.setT(glucose.getT());
+      return pocGlucose;
+    }
+    return null;
+  }
+
+  @SuppressLint("MissingPermission")
+  public static boolean isGattConnect(BluetoothDevice bluetoothDevice) {
+    BluetoothManager mBluetoothManager = (BluetoothManager) BApplication.getContext().getSystemService(Context.BLUETOOTH_SERVICE);
+    return mBluetoothManager.getConnectionState(bluetoothDevice, BluetoothProfile.GATT) == BluetoothProfile.STATE_CONNECTED;
+  }
+
+  /**
+   * 设置一个凯立特血糖数据
+   *
+   * @param pocGlucose 凯立特血糖数据
+   * @param glucose    计算出来的血糖数据
+   * @return 计算值返回
+   */
+  private static AlgorithmCallBack setPocGlucose(PocGlucose pocGlucose, CurrentGlucose glucose, PocDevice pocDevice) {
+    if (glucose == null) {
+      return new AlgorithmCallBack(AlgorithmCallBack.DATA_LOST, pocGlucose);
+    }
+    MyLog.wLog("CurrentGlucose = " + glucose.toString());
+    pocGlucose.setBGCount(glucose.getBGCount());
+    pocGlucose.setBGICount(glucose.getBGICount());
+    pocGlucose.setShowGlucose(Tool.getDecimalOneNumber(Tool.divide(glucose.getGluMG(), 18).floatValue()));
+    pocGlucose.setShowGlucoseMG(glucose.getGluMG());
+    pocGlucose.setGlucoseStatus(getGlucoseStatus(glucose));
+    pocGlucose.setTrend(getEnumTrend(glucose, pocDevice));
+    pocGlucose.setErrorCode(getEnumError(glucose));
+    pocGlucose.setCountdownDays(glucose.getCountdownDays());
+    pocGlucose.setCountdownHours(glucose.getCountdownHours());
+    pocGlucose.setCountdownMinutes(glucose.getCountdownMinutes());
+    if (pocGlucose.getErrorCode() == enumError.ERROR_DATA) {
+      return new AlgorithmCallBack(AlgorithmCallBack.ERROR_DATA, pocGlucose);
+    }
+    return new AlgorithmCallBack(AlgorithmCallBack.SUCCESS, pocGlucose);
+  }
+
+  /**
+   * 获取POC趋势
+   *
+   * @param glucose   计算的血糖数据类
+   * @param pocDevice
+   * @return 返回POC趋势
+   */
+  private static enumTrend getEnumTrend(CurrentGlucose glucose, PocDevice pocDevice) {
+    try {
+      if (glucose.getTrend() != Trend.TREND_NONE) {
+        return enumTrend.getEnumTrend(glucose.getTrend().getTrendId());
+      } else {
+        return enumTrend.NONE;
+      }
+    } catch (Exception e) {
+      e.printStackTrace();
+    }
+    return enumTrend.getEnumTrend(glucose.getTrend().getTrendId());
+  }
+
+  private static enumError getEnumError(CurrentGlucose glucose) {
+    return enumError.getEnumError(glucose.getErrorCode().getErrorId());
+  }
+
+  private static enumGlucoseStatus getGlucoseStatus(CurrentGlucose glucose) {
+    if (glucose != null && glucose.getGluMG() > 0 && glucose.getErrorCode() == ErrorCode.ERROR_NONE) {
+      float glu = Tool.getDecimalOneNumber(Tool.divide(glucose.getGluMG(), 18).floatValue());
+      if (glu > ConstantsLibrary.LIMIT_HYPERGLYCEMIA_MM_DEFAULT) {
+        return enumGlucoseStatus.HYPERGLYCEMIA;
+      } else if (glu < ConstantsLibrary.LIMIT_HYPOGLYCEMIA_MM_DEFAULT) {
+        return enumGlucoseStatus.HYPOGLYCEMIA;
+      }
+      return enumGlucoseStatus.NORMAL;
+    }
+    return enumGlucoseStatus.NONE;
+  }
+
+  /**
+   * 修改设备表，验证是否当前点满足结束初始化，若满足，重置设备为完成初始化状态
+   *
+   * @param context    上下文
+   * @param pocGlucose 血糖
+   * @param device     设备
+   */
+  public static PocDevice deviceInitComplete(Context context, @NonNull PocGlucose pocGlucose, @NonNull PocDevice device) {
+    if (context != null && device.isInit()) {
+      if (pocGlucose.getBGICount() > 0) {
+        device.setInitEndDate(new Date());
+        int updateId = RepositoryDevice.getInstance(context).updateDeviceIoThread(device);
+        if (updateId > 0) {
+          return RepositoryDevice.getInstance(context).getDeviceByIdIoThread(device.getId());
+        }
+      }
+    }
+    return device;
+  }
+
+  /**
+   * 主线程接触绑定
+   *
+   * @param context    上下文
+   * @param unBindType 解除绑定的类型
+   */
+  public static void unBindInDatabase(Context context, @NonNull enumUnBind unBindType) {
+    Observable.just(context)
+      .subscribeOn(Schedulers.io())
+      .map(con -> {
+        PocDevice device = RepositoryDevice.getInstance(con).getLatestDeviceIoThread();
+        return unBindInDatabaseIoThread(con, device, unBindType);
+      })
+      .observeOn(AndroidSchedulers.mainThread())
+      .subscribe();
+  }
+
+  /**
+   * 解除数据库绑定 -- 修改数据库中的信息
+   *
+   * @param context    上下文
+   * @param device     设备信息
+   * @param unBindType 解除的类型
+   */
+  public static boolean unBindInDatabaseIoThread(Context context, @NonNull PocDevice device, @NonNull enumUnBind unBindType) {
+    boolean isSuccess = RepositoryDevice.getInstance(context).unBindIoThread(device, unBindType);
+    if (isSuccess) {
+      switch (unBindType) {
+        case UNBIND_RESET:
+          //电池重置
+          ManagementLiveData.getInstance().updateOperationConnect(EnumConnect.CONNECT_UNBIND_RESET);
+          break;
+        default:
+          //其他,正常解除绑定
+          ManagementLiveData.getInstance().updateOperationConnect(EnumConnect.CONNECT_UNBIND_SUCCESS);
+          break;
+      }
+      ManageGattCallback.getInstance().unBindType = enumUnBind.NONE;
+      MyLog.clearLogAdapter();
+      ManageScanCallback.getInstance().stopLeScan();
+      ReconnectManagement.getInstance().stopReconnect();
+      ManageGattCallback.getInstance().removeHandler();
+    }
+    return isSuccess;
+  }
+}

package/android/src/main/java/cgmblelib/ble/gattcallback/LineUpTaskGlucoseProcess.java

@@ -0,0 +1,168 @@
+package cgmblelib.ble.gattcallback;
+
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+import cgmblelib.utils.MyLog;
+import ist.com.sdk.ProtocolTools;
+
+/**
+ * 队列 血糖计算
+ */
+public class LineUpTaskGlucoseProcess {
+    /**
+     * 链表的血糖数据
+     */
+    private LinkedList<ProtocolTools.Glucose> lineUpBeans;
+    /**
+     * 任务监听
+     */
+    private OnTaskListener onTaskListener;
+
+    /**
+     * 设置链表监听
+     * @param onTaskListener
+     * @return 返回当前类
+     */
+    public LineUpTaskGlucoseProcess setOnTaskListener(OnTaskListener onTaskListener) {
+        this.onTaskListener = onTaskListener;
+        return this;
+    }
+
+    public LineUpTaskGlucoseProcess() {
+        this.lineUpBeans = new LinkedList<>();
+    }
+
+    private static class SingletonInstance {
+        private static final LineUpTaskGlucoseProcess INSTANCE = new LineUpTaskGlucoseProcess();
+    }
+
+    public static LineUpTaskGlucoseProcess getInstance() {
+        return SingletonInstance.INSTANCE;
+    }
+
+
+    /**
+     * 加入排队
+     * @param glucose 一个任务
+     */
+    public void addTask(ProtocolTools.Glucose glucose){
+        if(lineUpBeans != null){
+            if (!checkTask()) {
+                if (onTaskListener != null) onTaskListener.nextTask(glucose);
+            }
+            MyLog.i("addTask " + glucose.toString());
+            lineUpBeans.addLast(glucose);
+        }
+    }
+
+    /**
+     * 批量加入队列任务
+     * @param glucoseList 批量数据
+     */
+    public void addTasks(List<ProtocolTools.Glucose> glucoseList){
+        if(lineUpBeans != null){
+            for (ProtocolTools.Glucose glucose:glucoseList){
+                lineUpBeans.addLast(glucose);
+            }
+            if (onTaskListener != null) onTaskListener.nextTask(getFirst());
+        }
+    }
+
+    /**
+     * 检查列表中是否有任务正在执行。
+     * @return true 表示有任务正在执行。
+     */
+    public boolean checkTask(){
+        boolean isTask = false;
+        if(lineUpBeans != null){
+            if(lineUpBeans.size() > 0) isTask = true;
+        }
+        return isTask;
+    }
+
+    /**
+     * 得到下一个执行的任务数据
+     * @return 返回下一个将要执行的任务， 返回null ,代表没有任务可以执行了
+     */
+    public ProtocolTools.Glucose getFirst(){
+        if(lineUpBeans!=null){
+            return lineUpBeans.getFirst();
+        }
+        return null;
+    }
+
+    /**
+     * 执行成功之后，删除排队中的任务。
+     * @param glucose 数据
+     */
+    private void deleteTask(ProtocolTools.Glucose glucose){
+        if(lineUpBeans != null){
+            for(int i = 0; i < lineUpBeans.size();i++){
+                ProtocolTools.Glucose task = lineUpBeans.get(i);
+                if(glucose.getId() == task.getId()){
+                    lineUpBeans.remove(task); // 删除任务
+                    break;
+                }
+            }
+        }
+    }
+
+    public void completedInitiative() {
+        completedInitiative(true);
+    }
+
+    /**
+     * 主动提前结束队列任务
+     */
+    public void completedInitiative(boolean isInitiative) {
+        if (lineUpBeans != null && lineUpBeans.size() > 0) {
+            Iterator<ProtocolTools.Glucose> iterator = lineUpBeans.iterator();
+            while (iterator.hasNext()) {
+                iterator.next();
+                iterator.remove();
+            }
+        }
+        if (onTaskListener != null) {
+            onTaskListener.completedTask(isInitiative);
+        }
+    }
+
+    /**
+     * 外部调用,表示任务已经执行完成了,当执行完成一个任务调用
+     * @param task 任务执行完了
+     */
+    public void finishTask(ProtocolTools.Glucose task){
+        MyLog.iLog("当前结束,下一个更好");
+        deleteTask(task); // 删除已经执行完成的任务。
+        if(lineUpBeans != null){
+            if(checkTask()){
+                if(onTaskListener!=null){
+                    onTaskListener.nextTask(lineUpBeans.getFirst());
+                }
+            } else {
+                if(onTaskListener != null){
+                    onTaskListener.completedTask(false);
+                }
+            }
+        }
+    }
+
+    /**
+     * 当第一个任务执行完成，发现列队中还存在任务， 将继续执行下一个任务
+     */
+    public interface OnTaskListener{
+        /**
+         * 执行下一个任务
+         * @param task 下一个需要执行的任务
+         */
+        void nextTask(ProtocolTools.Glucose task);
+
+        /**
+         *  所有任务执行完成,没有下一个任务了
+         * @param isInitiative 是否是主动提前结束，true表示任务提前中止了
+         */
+        void completedTask(boolean isInitiative);
+    }
+}