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

package/android/src/main/java/cgmblelib/ble/scancallback/ManageScanCallback.java

@@ -0,0 +1,316 @@
+package cgmblelib.ble.scancallback;
+
+import android.annotation.SuppressLint;
+import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.BluetoothDevice;
+import android.os.Build;
+
+import androidx.annotation.NonNull;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+import cgmblelib.ble.BleService;
+import cgmblelib.ble.gattcallback.BleGattCallback;
+import cgmblelib.ble.gattcallback.ManageGattCallback;
+import cgmblelib.ble.reconnectManagament.ReconnectManagement;
+import cgmblelib.custom.livedata.ManagementLiveData;
+import cgmblelib.custom.livedata.scan.EnumScan;
+import cgmblelib.database.entity.PocDevice;
+import cgmblelib.utils.ConstantsLibrary;
+import cgmblelib.utils.MyLog;
+import cgmblelib.utils.PermissionCheckTool;
+import cgmblelib.utils.Tool;
+import io.reactivex.Observable;
+import io.reactivex.android.schedulers.AndroidSchedulers;
+import io.reactivex.disposables.Disposable;
+import ist.com.sdk.ProtocolTools;
+
+/**
+ * 搜索控制类
+ * Created by minyuchun on 2019/12/23.
+ *
+ * @author minyuchun
+ */
+public class ManageScanCallback {
+    /**
+     * 默认的搜索时长
+     */
+    private final static int SCAN_INTERVAL_DEFAULT = 6 * 1000;
+    /**
+     * RXJava 订阅
+     */
+    private Disposable mDisposable;
+
+    public ManageScanCallback() {
+    }
+
+    private static class SingletonInstance {
+        private static final ManageScanCallback INSTANCE = new ManageScanCallback();
+    }
+
+    public static ManageScanCallback getInstance() {
+        return SingletonInstance.INSTANCE;
+    }
+
+    /**
+     * 服务
+     */
+    private BleService mService;
+    /**
+     * 协议
+     */
+    private ProtocolTools mProtocolTools;
+    /**
+     * 搜索到的设备
+     */
+    private List<BluetoothDevice> mScanLeDeviceList = new ArrayList<>();
+    /**
+     * 在API版本21以及之后的搜索类
+     */
+    private BleScanCallback mScanCallback;
+    /**
+     * 权限查看框架
+     */
+    private PermissionCheckTool mPermissionCheckTool;
+    /**
+     * 正在搜索设备的标志位
+     */
+    private boolean isScanning = true;
+    /**
+     * 需要连接的设备
+     */
+    private PocDevice mPocDevice;
+
+    private BluetoothAdapter adapter;
+
+    /**
+     * 初始化数据
+     *
+     * @param service 服务
+     */
+    public void init(@NonNull BleService service) {
+        mService = service;
+        mPermissionCheckTool = new PermissionCheckTool(service);
+        mScanCallback = new BleScanCallback();
+        mProtocolTools = new ProtocolTools();
+    }
+
+    /**
+     * 进行搜索重连
+     * 1.先停止搜索
+     * 2.设置需要重连的发射器
+     * 3.开始搜索->重连
+     *
+     * @param device 重连时候设置发射器信息
+     */
+    public void reConnectViaScan(PocDevice device) {
+        if (mService == null) {
+            MyLog.iLog("scan mService is null");
+            return;
+        }
+        if (adapter == null) {
+            adapter = Tool.getBluetoothAdapter(mService);
+        }
+        //首先停止以存在的搜索
+        stopLeScan();
+        //其次设置搜索需要的设备
+        mPocDevice = device;
+        //最后开始搜索
+        startScan();
+    }
+
+    /**
+     * 开始搜索蓝牙设备
+     */
+    public void startScan() {
+        MyLog.d("startScan");
+        if (isScanning) {
+            return;
+        }
+        try {
+            mScanLeDeviceList.clear();
+            if (adapter != null && adapter.isEnabled()) {
+                if (isBLEPermissionLocks()) {
+                    //没有GPS的权限
+                    MyLog.i("未获取本地权限");
+                    ManagementLiveData.getInstance().updateOperationScan(EnumScan.SCAN_ERROR_LOCAL_OFF);
+                } else if (!Tool.isGPSEnable_S(mService)) {
+                    //没有开启GPS服务
+                    MyLog.i("未开启GPS");
+                    ManagementLiveData.getInstance().updateOperationScan(EnumScan.SCAN_ERROR_GPS_OFF);
+                } else {
+                    //开始启动蓝牙搜索
+                    isScanning = mScanCallback.startScan(adapter);
+                }
+            } else {
+                ManagementLiveData.getInstance().updateOperationScan(EnumScan.SCAN_ERROR_BLUETOOTH_OFF);
+                ReconnectManagement.getInstance().stopReconnect();
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+            isScanning = false;
+        } finally {
+            if (isScanning) {
+                if (mPocDevice != null) {
+                    BleGattCallback.getInstance().closeGatt();
+                }
+                ManagementLiveData.getInstance().updateOperationScan(EnumScan.SCAN_START);
+                stopScanDelay();
+            } else {
+                isScanning = true;
+                stopLeScan();
+            }
+        }
+    }
+
+    /**
+     * 停止搜索蓝牙设备
+     */
+    public void stopLeScan() {
+        stopLeScan(false);
+    }
+
+    /**
+     * 停止搜索蓝牙设备
+     *
+     * @param isNextConnect 已经搜索到发射, 下一步 连接准备
+     */
+    public void stopLeScan(boolean isNextConnect) {
+        MyLog.i("stopLeScan");
+        if (!isScanning) {
+            return;
+        }
+        try {
+            disposable();
+            isScanning = false;
+            //关闭搜索
+            mScanCallback.stopLeScan(adapter);
+        } catch (Exception e) {
+            e.printStackTrace();
+        } finally {
+            if (!isScanning) {
+                //搜索结束
+                ManagementLiveData.getInstance().updateOperationScan(EnumScan.SCAN_END);
+            }
+            mPocDevice = null;
+        }
+    }
+
+    /**
+     * 蓝牙搜索后回调
+     *
+     * @param callbackType 回调类型
+     * @param device       设备
+     * @param scanRecord   蓝牙广播二进制数据
+     * @param rssi         接收到的功率
+     */
+    @SuppressLint("MissingPermission")
+    public synchronized void onScanResult(int callbackType, BluetoothDevice device, byte[] scanRecord, int rssi) {
+        if (mService == null || !isScanning) {
+            return;
+        }
+        //扫描重连部分
+        if (mPocDevice != null && mPocDevice.isBoundButDisConnect()) {
+            if (device != null && device.getAddress() != null && device.getName() != null) {
+                ProtocolTools.Verify verify = mProtocolTools.verify(scanRecord);
+                if (verify != null && verify.getName() != null) {
+                    if (mPocDevice.getAddress().equals(device.getAddress())) {
+                        //不管发射器开关是否重置了都去连接
+                        stopLeScan(true);
+                        MyLog.i("scan result");
+                        ManageGattCallback.getInstance().ConnectViaAddress(device.getAddress());
+                    }
+                }
+            }
+        } else {
+            //搜索扫描部分
+            BluetoothDevice bluetoothDevice = removeSameScanDevice(device);
+            if (bluetoothDevice != null) {
+                ProtocolTools.Verify verify = mProtocolTools.verify(scanRecord);
+                if (verify != null && verify.getName() != null && !verify.isBound()) {
+                    PocDevice pocDevice = new PocDevice(verify, bluetoothDevice.getAddress());
+                    MyLog.i(verify.toString());
+                    ManagementLiveData.getInstance().updateOperationScan(pocDevice, rssi);
+                }
+            }
+        }
+
+    }
+
+
+    /**
+     * 搜索失败
+     *
+     * @param errorCode 搜索失败
+     */
+    public void onScanFailed(int errorCode) {
+        MyLog.eLog("onScanFailed errorCode = " + errorCode);
+        stopLeScan();
+    }
+
+
+    /**
+     * 当系统蓝牙发生变化时, 搜索控制类的变化
+     *
+     * @param isBluetoothOpen 蓝牙是否开启
+     */
+    public void bluetoothChange(boolean isBluetoothOpen) {
+        if (isBluetoothOpen) {
+            ReconnectManagement.getInstance().reconnect(ReconnectManagement.ReconnectState.STATE_BLUETOOTH_ON);
+        } else {
+            stopLeScan();
+        }
+    }
+
+    /**
+     * 延时停止搜索
+     */
+    private void stopScanDelay() {
+        mDisposable = Observable.timer(SCAN_INTERVAL_DEFAULT, TimeUnit.MILLISECONDS)
+                .observeOn(AndroidSchedulers.mainThread())
+                .subscribe(aLong -> stopLeScan(), throwable -> {
+
+                });
+    }
+
+    /**
+     * 取消订阅任务
+     */
+    private void disposable() {
+        if (mDisposable != null && !mDisposable.isDisposed()) {
+            mDisposable.isDisposed();
+        }
+    }
+
+    /***
+     * 查看是否被授予local权限
+     * @return true：有权限未被授权
+     */
+    private boolean isBLEPermissionLocks() {
+        if (mPermissionCheckTool != null) {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S){
+                return mPermissionCheckTool.lacksPermissions(ConstantsLibrary.BLUETOOTH_S);
+            }
+            return mPermissionCheckTool.lacksPermissions(ConstantsLibrary.LOCAL_PERMISSION);
+        }
+        return false;
+    }
+
+    /**
+     * 排除搜索到相同的设备
+     *
+     * @param device 蓝牙设备
+     */
+    @SuppressLint("MissingPermission")
+    private synchronized BluetoothDevice removeSameScanDevice(BluetoothDevice device) {
+        if (device != null && device.getName() != null && device.getAddress() != null) {
+            if (!mScanLeDeviceList.contains(device)) {
+                mScanLeDeviceList.add(device);
+                return device;
+            }
+        }
+        return null;
+    }
+}

package/android/src/main/java/cgmblelib/custom/livedata/ManagementLiveData.java

@@ -0,0 +1,216 @@
+package cgmblelib.custom.livedata;
+
+import android.os.Build;
+
+import java.util.ArrayList;
+import java.util.Hashtable;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import cgmblelib.custom.livedata.connect.EnumConnect;
+import cgmblelib.custom.livedata.connect.OperationConnectLiveData;
+import cgmblelib.custom.livedata.scan.EnumScan;
+import cgmblelib.custom.livedata.scan.OperationScanLiveData;
+import cgmblelib.custom.livedata.scan.PocDeviceAndRssi;
+import cgmblelib.database.entity.PocDevice;
+import cgmblelib.utils.MyLog;
+
+/**
+ * 自定义LiveData控制类
+ * @author minyuchun
+ */
+public class ManagementLiveData {
+
+    private Map<Integer, OperationScanLiveData.OperationScanListener> mScanListenerMap = new Hashtable<>();
+
+    private Map<Integer, OperationConnectLiveData.OperationConnectListener> mConnectListenerMap = new Hashtable<>();
+
+    private OperationScanLiveData.OperationScanListener mScanListener = null;
+
+    private OperationConnectLiveData.OperationConnectListener mConnectListener = null;
+
+    private List<PocDevice> mDeviceList;
+
+    private ManagementLiveData() {}
+    private static class SingletonInstance {
+        private static final ManagementLiveData INSTANCE = new ManagementLiveData();
+    }
+    public static ManagementLiveData getInstance() {
+        return SingletonInstance.INSTANCE;
+    }
+
+    public void requestOperationScan(OperationScanLiveData.OperationScanListener listener){
+        mScanListener = listener;
+    }
+
+    public void removeOperationScan(){
+        mScanListener = null;
+    }
+
+    public int requestOperationScanUpdate(OperationScanLiveData.OperationScanListener listener){
+        int listerId = mScanListenerMap.size() + 1;
+        mScanListenerMap.put(listerId,listener);
+        if (mScanListenerMap.containsKey(listerId)){
+            return listerId;
+        }
+        return 0;
+    }
+
+    public boolean removeOperationScanUpdate(int mapKey, OperationScanLiveData.OperationScanListener listener){
+        if (mScanListenerMap.containsKey(mapKey)){
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+                return mScanListenerMap.remove(mapKey,listener);
+            } else {
+                return mScanListenerMap.remove(mapKey) != null;
+            }
+        }
+        return false;
+    }
+
+
+    public synchronized void updateOperationScan(EnumScan scan){
+        try {
+            if (scan == null){
+                return;
+            }
+            if (scan == EnumScan.SCAN_START){
+                mDeviceList = new ArrayList<>();
+            }
+            if (mScanListenerMap != null && !mScanListenerMap.isEmpty()){
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+                    mScanListenerMap.forEach((integer, listener) -> listener.onChanged(scan,null));
+                } else {
+                    for (OperationScanLiveData.OperationScanListener listener : mScanListenerMap.values()) {
+                        listener.onChanged(scan, null);
+                    }
+                }
+            }
+            if (mScanListener != null){
+                MyLog.d("updateOperationScan " + scan);
+                mScanListener.onChanged(scan, null);
+            } else {
+                MyLog.d("mScanListener is NUll " + scan);
+            }
+        } catch (Exception e){
+            e.printStackTrace();
+        }
+    }
+
+    public synchronized void updateOperationScan(PocDevice pocDevice, int rssi){
+        if (pocDevice == null){
+            return;
+        }
+        if (mDeviceList == null){
+            mDeviceList = new ArrayList<>();
+        }
+        if (mScanListenerMap != null && !mScanListenerMap.isEmpty()){
+            AtomicBoolean sameAddress = new AtomicBoolean(false);
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+                mDeviceList.forEach(device -> {
+                    if (device.getAddress().equals(pocDevice.getAddress())){
+                        sameAddress.set(true);
+                    }
+                });
+                if (!sameAddress.get()){
+                    mDeviceList.add(pocDevice);
+                    mScanListenerMap.forEach((integer, listener) -> listener.onChanged(EnumScan.SCAN_IN,new PocDeviceAndRssi(pocDevice,rssi)));
+                }
+            } else {
+                for (PocDevice device:mDeviceList){
+                    if (device.getAddress().equals(pocDevice.getAddress())){
+                        sameAddress.set(true);
+                    }
+                }
+                if (!sameAddress.get()) {
+                    mDeviceList.add(pocDevice);
+                    for (OperationScanLiveData.OperationScanListener listener : mScanListenerMap.values()) {
+                        listener.onChanged(EnumScan.SCAN_IN, new PocDeviceAndRssi(pocDevice,rssi));
+                    }
+                }
+            }
+
+        }
+
+        if (mScanListener != null) {
+            AtomicBoolean sameAddress = new AtomicBoolean(false);
+            for (PocDevice device : mDeviceList) {
+                if (device.getAddress().equals(pocDevice.getAddress())) {
+                    sameAddress.set(true);
+                }
+            }
+            if (!sameAddress.get()) {
+                mDeviceList.add(pocDevice);
+//                MyLog.i("updateOperationScan " + pocDevice.toString());
+                mScanListener.onChanged(EnumScan.SCAN_IN, new PocDeviceAndRssi(pocDevice,rssi));
+            } else {
+                MyLog.e("sameAddress = " + sameAddress.get());
+            }
+        } else {
+            MyLog.e("mScanListener is null");
+        }
+    }
+
+
+    public void requestOperationConnect(OperationConnectLiveData.OperationConnectListener listener){
+        mConnectListener = listener;
+    }
+
+    public void removeOperationConnect(){
+        mConnectListener = null;
+    }
+
+
+    public int requestOperationConnectUpdate(OperationConnectLiveData.OperationConnectListener listener){
+        int listerId = mScanListenerMap.size() + 1;
+        mConnectListenerMap.put(listerId,listener);
+        if (mConnectListenerMap.containsKey(listerId)){
+            return listerId;
+        }
+        return 0;
+    }
+
+    public boolean removeOperationConnectUpdate(int mapKey, OperationConnectLiveData.OperationConnectListener listener){
+        if (mConnectListenerMap.containsKey(mapKey)){
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+                return mConnectListenerMap.remove(mapKey,listener);
+            } else {
+                return mConnectListenerMap.remove(mapKey) != null;
+            }
+        }
+        return false;
+    }
+
+    public void updateOperationConnect(EnumConnect connect){
+        if (connect == null){
+            return;
+        }
+        if (mConnectListenerMap != null && !mConnectListenerMap.isEmpty()){
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+                mConnectListenerMap.forEach((integer, operationConnectListener) -> operationConnectListener.onChanged(connect,0));
+            } else {
+                for (OperationConnectLiveData.OperationConnectListener operationConnectListener: mConnectListenerMap.values()) {
+                    operationConnectListener.onChanged(connect,0);
+                }
+            }
+        }
+        if (mConnectListener != null){
+            mConnectListener.onChanged(connect,0);
+        }
+    }
+
+    public void updateOperationConnect(int glucoseId){
+        if (mConnectListenerMap != null && !mConnectListenerMap.isEmpty()){
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+                mConnectListenerMap.forEach((integer, operationConnectListener) -> operationConnectListener.onChanged(EnumConnect.CONNECT_PULL_IN,glucoseId));
+            } else {
+                for (OperationConnectLiveData.OperationConnectListener operationConnectListener: mConnectListenerMap.values()) {
+                    operationConnectListener.onChanged(EnumConnect.CONNECT_PULL_IN,glucoseId);
+                }
+            }
+        }
+        if (mConnectListener != null){
+            mConnectListener.onChanged(EnumConnect.CONNECT_PULL_IN,glucoseId);
+        }
+    }
+}

package/android/src/main/java/cgmblelib/custom/livedata/connect/EnumConnect.java

@@ -0,0 +1,30 @@
+package cgmblelib.custom.livedata.connect;
+
+/**
+ * 搜索类型的枚举
+ * @author minyuchun
+ */
+public enum EnumConnect {
+    CONNECT_NONE,
+    CONNECT_START,
+    CONNECT_SUCCESS,
+    CONNECT_FAIL_133,
+    CONNECT_FAIL_257,
+    CONNECT_FAIL_59,
+    CONNECT_BIND_SUCCESS,
+    CONNECT_BIND_FAIL,
+    CONNECT_BIND_CHECK_LOW_POWER,
+    CONNECT_BIND_CHECK_ERROR_TEMPERATURE,
+    CONNECT_DISCONNECT,
+    CONNECT_DISCONNECT_TIMEOUT,
+    CONNECT_PULL_START,
+    CONNECT_PULL_IN,
+    CONNECT_PULL_END,
+    CONNECT_UNBIND_START,
+    CONNECT_UNBIND_SUCCESS,
+    CONNECT_UNBIND_RESET,
+    CONNECT_ONLINE_LOST,
+    CONNECT_ONLINE_RECONNECT,
+    CONNECT_MISMATCHED_SENSOR_TRANSMITTER,
+    ;
+}

package/android/src/main/java/cgmblelib/custom/livedata/connect/OperationConnectBean.java

@@ -0,0 +1,51 @@
+package cgmblelib.custom.livedata.connect;
+
+/**
+ * 搜索操作类
+ * @author minyuchun
+ */
+public class OperationConnectBean {
+    /**
+     * 搜索类型
+     */
+    private EnumConnect mConnect;
+    /**
+     * 当  mScan == SCAN_START 时搜索道的发射器设备集合
+     */
+    private int glucoseId;
+
+    public OperationConnectBean() {}
+
+    public OperationConnectBean(EnumConnect connect) {
+        mConnect = connect;
+    }
+
+    public OperationConnectBean(EnumConnect connect, int glucoseId) {
+        mConnect = connect;
+        this.glucoseId = glucoseId;
+    }
+
+    public EnumConnect getConnect() {
+        return mConnect;
+    }
+
+    public void setConnect(EnumConnect connect) {
+        mConnect = connect;
+    }
+
+    public int getGlucoseId() {
+        return glucoseId;
+    }
+
+    public void setGlucoseId(int glucoseId) {
+        this.glucoseId = glucoseId;
+    }
+
+    @Override
+    public String toString() {
+        return "OperationConnectBeanBean{" +
+                "mConnect=" + mConnect +
+                ", glucoseId=" + glucoseId +
+                '}';
+    }
+}

package/android/src/main/java/cgmblelib/custom/livedata/connect/OperationConnectLiveData.java

@@ -0,0 +1,66 @@
+package cgmblelib.custom.livedata.connect;
+
+import androidx.annotation.MainThread;
+import androidx.lifecycle.LiveData;
+
+import cgmblelib.custom.livedata.ManagementLiveData;
+import cgmblelib.utils.Tool;
+
+/**
+ * Created by minyuchun on 2019/10/23.
+ * 用户在Service中获取设备信息变化
+ * @author minyuchun
+ */
+public class OperationConnectLiveData extends LiveData<OperationConnectBean> {
+
+    private static volatile OperationConnectLiveData sInstance;
+
+    private OperationConnectBean mBean = new OperationConnectBean(EnumConnect.CONNECT_NONE);
+
+    private OperationConnectListener mListener = (connect, glucosedId) -> {
+        mBean.setConnect(connect);
+        mBean.setGlucoseId(glucosedId);
+        if (Tool.isInMainThread()) {
+            setValue(mBean);
+        } else {
+            postValue(mBean);
+        }
+    };
+
+    public OperationConnectLiveData() {
+        if (Tool.isInMainThread()) {
+            setValue(mBean);
+        } else {
+            postValue(mBean);
+        }
+    }
+
+    public void setListener(OperationConnectListener listener) {
+        mListener = listener;
+    }
+
+    @MainThread
+    public static OperationConnectLiveData get() {
+        if (sInstance == null) {
+            sInstance = new OperationConnectLiveData();
+        }
+        return sInstance;
+    }
+
+
+    @Override
+    protected void onActive() {
+//        keyId = ManagementLiveData.getInstance().requestOperationConnectUpdate(mListener);
+        ManagementLiveData.getInstance().requestOperationConnect(mListener);
+    }
+
+    @Override
+    protected void onInactive() {
+        ManagementLiveData.getInstance().removeOperationConnect();
+    }
+
+
+    public interface OperationConnectListener{
+        void onChanged(EnumConnect connect, int glucosedId);
+    }
+}

package/android/src/main/java/cgmblelib/custom/livedata/scan/EnumScan.java

@@ -0,0 +1,25 @@
+package cgmblelib.custom.livedata.scan;
+
+/**
+ * 搜索类型的枚举
+ * @author minyuchun
+ */
+public enum EnumScan {
+    SCAN_NONE,
+    /**开始搜索*/
+    SCAN_START,
+    /**正在搜索中*/
+    SCAN_IN,
+    /**结束搜索*/
+    SCAN_END,
+    /**搜索时，系统蓝牙被关闭*/
+    SCAN_ERROR_BLUETOOTH_OFF,
+    /**搜索时，系统蓝牙被开启(蓝牙从关闭状态变为开启状态)*/
+    SCAN_ERROR_BLUETOOTH_ON,
+    /**搜索时，系统的GPS定位未开启(在Android 12以下 需要使用定位权限)*/
+    SCAN_ERROR_GPS_OFF,
+    /**搜索时，系统的定位权限未授予(在Android 12以下 需要使用定位权限)*/
+    SCAN_ERROR_LOCAL_OFF,
+    /**搜索时，进行创建连接时失败(Android 12及以上时没有给予蓝牙权限)*/
+    SCAN_ERROR_CONNECT_OFF,
+}