@quec/rn-device-module 1.9.19 → 2.16.1

package/android/src/main/java/com/quectel/smart/rnplugin/quecrndevicemodule/QuecRNDeviceModule.java

@@ -0,0 +1,2423 @@
+package com.quectel.smart.rnplugin.quecrndevicemodule;
+
+import android.app.Activity;
+import android.text.TextUtils;
+import android.util.Base64;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableType;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.module.annotations.ReactModule;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter;
+import com.google.gson.Gson;
+import com.google.gson.reflect.TypeToken;
+import com.quectel.app.device.bean.BatchControlDevice;
+import com.quectel.app.device.bean.BatchDeleteCloudTiming;
+import com.quectel.app.device.bean.ChannelStateEvent;
+import com.quectel.app.device.bean.CloudTimingList;
+import com.quectel.app.device.bean.DpsHttpExtraDataBean;
+import com.quectel.app.device.bean.ModelBasic;
+import com.quectel.app.device.bean.QuecBatchControlDeviceModel;
+import com.quectel.app.device.bean.QuecBatchControlExtraModel;
+import com.quectel.app.device.bean.QuecCornJobModel;
+import com.quectel.app.device.bean.QuecDeviceListParamsModel;
+import com.quectel.app.device.bean.QuecProductTSLPropertyModel;
+import com.quectel.app.device.bean.QuecVoiceSupport;
+import com.quectel.app.device.bean.RefreshUnbindDeviceEvent;
+import com.quectel.app.device.bean.TSLEvent;
+import com.quectel.app.device.bean.TSLService;
+import com.quectel.app.device.callback.IDeviceTSLCallBack;
+import com.quectel.app.device.callback.IDeviceTSLModelCallback;
+import com.quectel.app.device.deviceservice.IDevService;
+import com.quectel.app.device.deviceservice.QuecDeviceAssociateService;
+import com.quectel.app.device.deviceservice.QuecDeviceControlService;
+import com.quectel.app.device.deviceservice.QuecDeviceGroupService;
+import com.quectel.app.device.deviceservice.QuecDeviceService;
+import com.quectel.app.device.deviceservice.QuecDeviceShareService;
+import com.quectel.app.device.deviceservice.QuecDeviceStatisticsService;
+import com.quectel.app.device.iot.IotChannelController;
+import com.quectel.app.device.utils.CacheTSLModel;
+import com.quectel.app.device.utils.DeviceServiceFactory;
+import com.quectel.app.device.utils.JsonUtils;
+import com.quectel.app.device.utils.ObjectModelParse;
+import com.quectel.app.device.utils.WebSocketServiceLocater;
+import com.quectel.app.quecnetwork.httpservice.IHttpCallBack;
+import com.quectel.app.smart_home_sdk.bean.QuecFamilyDeviceListParamsModel;
+import com.quectel.app.smart_home_sdk.service.QuecSmartHomeService;
+import com.quectel.app.websocket.deviceservice.IWebSocketService;
+import com.quectel.app.websocket.websocket.EventType;
+import com.quectel.app.websocket.websocket.SocketEvent;
+import com.quectel.app.websocket.websocket.SuccessEventContent;
+import com.quectel.app.websocket.websocket.WsManager;
+import com.quectel.basic.common.base.QuecBaseApp;
+import com.quectel.basic.common.entity.QuecCallback;
+import com.quectel.basic.common.entity.QuecDeviceModel;
+import com.quectel.basic.common.entity.QuecError;
+import com.quectel.basic.common.entity.QuecPageResponse;
+import com.quectel.basic.common.entity.QuecResult;
+import com.quectel.basic.common.entity.QuecSimpleCallBack;
+import com.quectel.basic.common.event.QuecBaseEvent;
+import com.quectel.basic.common.utils.QuecCacheDataUtils;
+import com.quectel.basic.common.utils.QuecGsonUtil;
+import com.quectel.basic.common.utils.QuecThreadUtil;
+import com.quectel.basic.common.utils.QuecTimeZoneUtil;
+import com.quectel.basic.common.utils.QuecToastUtil;
+import com.quectel.basic.queclog.QLog;
+import com.quectel.basic.quecmmkv.MmkvManager;
+import com.quectel.basic.rn.QuecReadableMapUtil;
+import com.quectel.business.device.list.api.QuecDeviceListServiceManager;
+import com.quectel.business.device.list.api.RefreshDeviceListEvent;
+import com.quectel.business.device.list.api.model.DeviceModel;
+import com.quectel.business.device.panel.api.Constants;
+import com.quectel.business.device.panel.api.QuecDevicePanelServiceManager;
+import com.quectel.business.device.panel.api.events.QuecDeviceModelUpdateEvent;
+import com.quectel.business.device.panel.api.events.QuecSelectedDeviceEvent;
+import com.quectel.business.ota.upgrade.api.OtaUpgradeServiceManager;
+import com.quectel.business.quecMain.api.QuecMainConstant;
+import com.quectel.business.smart.config.api.SmartConfigServiceManager;
+import com.quectel.business.wifiSwitch.module.api.QuecWifiSwitchUIServiceManager;
+import com.quectel.sdk.iot.channel.kit.QuecDeviceDataUploadManager;
+import com.quectel.sdk.iot.channel.kit.QuecIotChannelManager;
+import com.quectel.oem.config.QuecOemAppConfig;
+import com.quectel.sdk.iot.channel.kit.constaint.QuecIotChannelType;
+import com.quectel.sdk.iot.channel.kit.constaint.QuecIotDataSendMode;
+import com.quectel.sdk.iot.channel.kit.model.QuecIotChannelExtraData;
+import com.quectel.sdk.iot.channel.kit.model.QuecIotDataPointsModel;
+import com.quectel.sdk.iot.channel.kit.v2.QuecDeviceClient;
+import com.quectel.sdk.iot.channel.kit.v2.QuecDeviceClientApi;
+import com.quectel.sdk.mvvm.QuecBaseViewModel;
+import com.quectel.sdk.ota.upgrade.entry.QuecOtaInfo;
+import com.quectel.sdk.ota.upgrade.v2.QuecOtaManager;
+import com.quectel.smart.rnplugin.quecrndevicemodule.utils.AnalysisChannelDataUtils;
+import com.quectel.smart.rnplugin.quecrndevicemodule.utils.DataConvertUtils;
+import com.quectel.smart.rnplugin.quecrndevicemodule.utils.ErrorCode;
+import com.quectel.smart.rnplugin.quecrndevicemodule.utils.IpcUtil;
+import com.quectel.smart.rnplugin.quecrndevicemodule.utils.NetUtils;
+import com.quectel.smart.rnplugin.quecrndevicemodule.utils.ParamsValueUtils;
+import com.quectel.smart.rnplugin.quecrndevicemodule.utils.ReactNativeJson;
+import com.quectel.smart.rnplugin.quecrndevicemodule.utils.ResponseUtils;
+
+import org.greenrobot.eventbus.EventBus;
+import org.greenrobot.eventbus.Subscribe;
+import org.greenrobot.eventbus.ThreadMode;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.CountDownLatch;
+
+/**
+ * @version: 1.0.0
+ * @owner: vic.huang@quectel.com
+ * @platform: all
+ * 设备桥组件
+ */
+@ReactModule(name = "QuecRNDeviceModule")
+public class QuecRNDeviceModule extends ReactContextBaseJavaModule implements IQuecRNDeviceModuleSpec {
+    private static final String NO_NETWORK_MSG = "";
+    private static final String TAG = "QuecRNDeviceModule";
+    private static final String PRODUCT_KEY_NAME = "productKey";
+    private static final String DEVICE_KEY_NAME = "deviceKey";
+    private final CountDownLatch latch = new CountDownLatch(1);
+    private final QuecBaseViewModel viewModel = new QuecBaseViewModel();
+    private final List<QuecDeviceModel> deviceModelList = new ArrayList<>();
+    /**
+     * 多设备关联项目 since 2.8.8
+     * 主设备已绑定的其他设备
+     */
+    private final Set<String> otherChannelIds = new HashSet<>();
+
+    private QuecDeviceModel deviceModel = null;
+    private volatile String channelId = "";
+    private QuecDeviceClientApi deviceClient = QuecDeviceClient.Companion.initWithDevice(new QuecDeviceModel("", ""));
+    private final QuecDeviceClientApi.Listener listener = new QuecDeviceClientApi.Listener() {
+
+        @Override
+        public void dpsUpdate(@NonNull QuecDeviceModel quecDeviceModel,
+                              @NonNull QuecIotDataPointsModel quecIotDataPointsModel) {
+
+        }
+
+        @Override
+        public void deviceRemoved(@NonNull QuecDeviceModel quecDeviceModel) {
+
+        }
+
+        @Override
+        public void onlineUpdate(@NonNull QuecDeviceModel quecDeviceModel, int onlineState) {
+            QLog.i(TAG, "[" + Thread.currentThread().getName() + "] - [" + quecDeviceModel.getChannelId() + "] " +
+                    "onlineUpdate: " + onlineState);
+            WritableMap writableMap = Arguments.createMap();
+            writableMap.putString("onlineState", onlineState + "");
+            try {
+                //多设备模式下需要返回device信息，否则不知道哪个设备的状态
+                DeviceModel deviceModel = new DeviceModel();
+                deviceModel.setProductKey(quecDeviceModel.getProductKey());
+                deviceModel.setDeviceKey(quecDeviceModel.getDeviceKey());
+                deviceModel.setOnlineStatus(onlineState);
+                JSONObject jsonObject = new JSONObject(QuecGsonUtil.INSTANCE.gsonString(deviceModel));
+                WritableMap device = ReactNativeJson.convertJsonToMap(jsonObject);
+                writableMap.putMap(Constants.DEVICE_PANEL_DEVICE_MODEL, device);
+            } catch (JSONException e) {
+                QLog.d(TAG, e.toString());
+            }
+            onDeviceOnlineState(writableMap);
+        }
+
+        @Override
+        public void deviceInfoUpdate(@NonNull QuecDeviceModel quecDeviceModel) {
+
+        }
+
+        @Override
+        public void connectingStateUpdate(@NonNull QuecDeviceModel quecDeviceModel, int connectingState) {
+            sendConnectingStateEvent(connectingState);
+        }
+    };
+
+    private final QuecCallback<QuecBaseEvent> deviceEventCallback = result -> onEvent(result.getData());
+
+    public QuecRNDeviceModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+        if (!EventBus.getDefault().isRegistered(QuecRNDeviceModule.this)) {
+            EventBus.getDefault().register(QuecRNDeviceModule.this);
+        }
+
+        QuecDevicePanelServiceManager.getInstance().addDeviceInfoEventCallback(deviceEventCallback);
+        initData();
+//        initIotChannelEvent();
+    }
+
+    @Override
+    public void initialize() {
+        super.initialize();
+        QLog.d(TAG, "init");
+        latch.countDown(); // 标记初始化完成
+    }
+
+    /**
+     * 解析js层传递过来的数据 转换成 QuecIotDataPointsModel.DataModel
+     */
+    private List<QuecIotDataPointsModel.DataModel> getData(ReadableArray dps, Promise promise) {
+        List<QuecIotDataPointsModel.DataModel> list = new ArrayList<>();
+        try {
+            JSONArray array = ReactNativeJson.convertArrayToJson(dps);
+            if (array.length() == 0) {
+                return list;
+            }
+            for (int i = 0; i < array.length(); i++) {
+                QuecIotDataPointsModel.DataModel model = new QuecIotDataPointsModel.DataModel();
+                JSONObject jobj = array.getJSONObject(i);
+                if (jobj != null) {
+                    model.setId(jobj.optInt("id"));
+                    model.setDataType(jobj.optString("dataType"));
+                    model.setCode(jobj.optString("code"));
+                    if (model.getDataType().equals(QuecIotDataPointsModel.DataModel.QuecIotDataPointDataType.ARRAY_NUM)) {
+                        //数组类型
+                        model.setValue(handleArray(jobj));
+                    } else if (model.getDataType().equals(QuecIotDataPointsModel.DataModel.QuecIotDataPointDataType.STRUCT_NUM)) {
+                        //结构体类型
+                        model.setValue(handleStruct(jobj));
+                    } else {
+                        //基本数据类型
+                        model.setValue(jobj.optString("value"));
+                    }
+                    list.add(model);
+                }
+            }
+        } catch (JSONException e) {
+            promise.reject(ErrorCode.ERROR_CODE_JSON_EXCEPTION, e);
+            QLog.e(TAG, e.toString());
+        }
+        return list;
+    }
+
+    /**
+     * 处理数据数据类型
+     */
+    private List<QuecIotDataPointsModel.DataModel> handleArray(JSONObject jobj) {
+        JSONArray jsonArray = jobj.optJSONArray("value");
+        List<QuecIotDataPointsModel.DataModel> childList = new ArrayList<>();
+        if (jsonArray != null && jsonArray.length() > 0) {
+            for (int j = 0; j < jsonArray.length(); j++) {
+                JSONObject jsonObject = (JSONObject) jsonArray.opt(j);
+                QuecIotDataPointsModel.DataModel model1 = new QuecIotDataPointsModel.DataModel();
+                if (jsonObject != null) {
+                    model1.setId(jsonObject.optInt("id"));
+                    model1.setDataType(jsonObject.optString("dataType"));
+                    if (model1.getDataType().equals(QuecIotDataPointsModel.DataModel.QuecIotDataPointDataType.STRUCT_NUM)) {
+                        //结构体类型
+                        model1.setValue(handleStruct(jsonObject));
+                    } else {
+                        //基本数据类型
+                        model1.setValue(jsonObject.optString("value"));
+                    }
+                }
+                childList.add(model1);
+            }
+        }
+        return childList;
+    }
+
+    /**
+     * 处理结构体数据类型
+     */
+    private List<QuecIotDataPointsModel.DataModel> handleStruct(JSONObject jobj) {
+        //结构体类型
+        List<QuecIotDataPointsModel.DataModel> childList = new ArrayList<>();
+        JSONArray jsonArray = jobj.optJSONArray("value");
+        if (jsonArray != null && jsonArray.length() > 0) {
+            for (int j = 0; j < jsonArray.length(); j++) {
+                JSONObject jsonObject = (JSONObject) jsonArray.opt(j);
+                QuecIotDataPointsModel.DataModel model = new QuecIotDataPointsModel.DataModel();
+                if (jsonObject != null) {
+                    //基本数据类型
+                    model.setId(jsonObject.optInt("id"));
+                    model.setCode(jsonObject.optString("code"));
+                    model.setDataType(jsonObject.optString("dataType"));
+                    model.setValue(jsonObject.optString("value"));
+                }
+                childList.add(model);
+            }
+        }
+        return childList;
+    }
+
+    @ReactMethod
+    @Override
+    public void isWebSocketSubscribe(Promise promise) {
+        boolean isSubscribe = IotChannelController.getInstance().isWebsocketSubscribe(deviceModel);
+        WritableMap map = Arguments.createMap();
+        map.putBoolean("subscribe", isSubscribe);
+        promise.resolve(map);
+    }
+
+    @ReactMethod
+    @Override
+    public void getDeviceConnectingState(Promise promise) {
+        int state = IotChannelController.getInstance().getDeviceConnectingState(deviceModel);
+        WritableMap map = Arguments.createMap();
+        map.putInt("connectingState", state);
+        promise.resolve(map);
+    }
+
+    /**
+     * writeDpsByHttp
+     *
+     * @param dps        – dps [ {id:0, type:BOOL, value:false} ,{id:1, type:INT, value:2}]
+     * @param deviceList – deviceList 设备列表 [{"deviceKey":"", "productKey":""}]
+     * @param type       - 类型 1：透传 2：属性 3：服务
+     * @param extraData  – {
+     *                   dataFormat 数据类型 1：Hex 2：Text（当type为透传时，需要指定 dataFormat）
+     *                   cacheTime 缓存时间，单位为秒，缓存时间范围 1-7776000 秒，启用缓存时必须设置缓存时间
+     *                   isCache  是否启用缓存 1：启用 2：不启用，默认不启用
+     *                   isCover 是否覆盖之前发送的相同的命令 1：覆盖 2：不覆盖，默认不覆盖，启用缓存时此参数有效
+     *                   <p>
+     *                   查看接口定义
+     *                   }
+     **/
+    @ReactMethod
+    @Override
+    public void writeDpsByHttp(ReadableArray dps, ReadableArray deviceList, int type, final ReadableMap extraData,
+                               final Promise promise) {
+        List<QuecIotDataPointsModel.DataModel> list = getData(dps, promise);
+        List<QuecIotDataPointsModel.DataModel> dpsList = new ArrayList<>(list);
+        List<BatchControlDevice> devices = new ArrayList<>();
+        for (int i = 0; i < deviceList.size(); i++) {
+            BatchControlDevice device = new BatchControlDevice();
+            ReadableMap map = deviceList.getMap(i);
+            if (map.hasKey("deviceKey")) {
+                device.setDeviceKey(map.getString("deviceKey"));
+            } else {
+                promise.reject("fail", "deviceKey is null");
+                return;
+            }
+            if (map.hasKey("productKey")) {
+                device.setProductKey(map.getString("productKey"));
+            } else {
+                promise.reject("fail", "productKey is null");
+                return;
+            }
+            devices.add(device);
+        }
+        DpsHttpExtraDataBean extraDataBean = new DpsHttpExtraDataBean();
+        if (extraData.hasKey("dataFormat")) {
+            int dataFormat = extraData.getInt("dataFormat");
+            extraDataBean.setDataFormat(dataFormat);
+        }
+        if (extraData.hasKey("cacheTime")) {
+            int cacheTime = extraData.getInt("cacheTime");
+            extraDataBean.setCacheTime(cacheTime);
+        }
+        if (extraData.hasKey("isCache")) {
+            int isCache = extraData.getInt("isCache");
+            extraDataBean.setIsCache(isCache);
+        }
+        if (extraData.hasKey("isCover")) {
+            int dataFormat = extraData.getInt("isCover");
+            extraDataBean.setCover(dataFormat);
+        }
+        IotChannelController.getInstance().writeDpsByHttp(dpsList, devices, type, extraDataBean, quecResult -> {
+            if (quecResult.successCode()) {
+                String str = QuecGsonUtil.INSTANCE.gsonString(quecResult);
+                try {
+                    JSONObject jsonObject = new JSONObject(str);
+                    WritableMap map = ReactNativeJson.convertJsonToMap(jsonObject);
+                    promise.resolve(map);
+                } catch (JSONException e) {
+                    promise.reject("fail", new Throwable(e));
+                }
+            } else if (quecResult.getCode() == 0) {
+                promise.reject(ErrorCode.ERROR_CODE_REQUEST_FAIL, quecResult.getMsg());
+            } else {
+                try {
+                    String str = QuecGsonUtil.INSTANCE.gsonString(quecResult);
+                    JSONObject jsonObject = new JSONObject(str);
+                    WritableMap map = ReactNativeJson.convertJsonToMap(jsonObject);
+                    promise.reject("fail", map);
+                } catch (JSONException e) {
+                    promise.reject("fail", new Throwable(e));
+                }
+            }
+        });
+    }
+
+    @Override
+    public void readDpsWithExtraData(ReadableArray dps, ReadableMap extraData, final Promise promise) {
+        deviceClient.readDps(getData(dps, promise), getDefaultDataSendMode(), getExtraData(extraData),
+                getSimpleCallback(promise));
+    }
+
+    @Override
+    public void readDpsWithExtraDataAndMode(ReadableArray dps, ReadableMap extraData, int mode, final Promise promise) {
+        deviceClient.readDps(getData(dps, promise), getDataSendMode(mode), getExtraData(extraData),
+                getSimpleCallback(promise));
+    }
+
+    @ReactMethod
+    @Override
+    public void writeDpsWithExtraData(ReadableArray dps, ReadableMap extraData, final Promise promise) {
+        deviceClient.writeDps(getData(dps, promise), getDefaultDataSendMode(), getExtraData(extraData),
+                getSimpleCallback(promise));
+    }
+
+    @ReactMethod
+    @Override
+    public void writeDpsWithExtraDataAndMode(ReadableArray dps, ReadableMap extraData, int mode,
+                                             final Promise promise) {
+        deviceClient.writeDps(getData(dps, promise), getDataSendMode(mode), getExtraData(extraData),
+                getSimpleCallback(promise));
+    }
+
+    private QuecIotChannelExtraData getExtraData(ReadableMap extraData) {
+        if (null == extraData) return null;
+        QuecIotChannelExtraData data = new QuecIotChannelExtraData();
+        if (extraData.hasKey("msgId") && extraData.getType("msgId") == ReadableType.Number) {
+            int msgId = extraData.getInt("msgId");
+            data.setMsgId((long) msgId);
+        }
+        if (extraData.hasKey("cacheTime") && extraData.getType("cacheTime") == ReadableType.Number) {
+            int cacheTime = extraData.getInt("cacheTime");
+            data.setMsgId((long) cacheTime);
+        }
+        if (extraData.hasKey("isCover") && extraData.getType("isCover") == ReadableType.Boolean) {
+            boolean isCover = extraData.getBoolean("isCover");
+            data.setCover(isCover);
+        }
+        if (extraData.hasKey("isSendJson") && extraData.getType("isSendJson") == ReadableType.Boolean) {
+            boolean isSendJson = extraData.getBoolean("isSendJson");
+            data.setSendJson(isSendJson);
+        }
+        return data;
+    }
+
+    @Override
+    @ReactMethod
+    public void getBleState(Promise promise) {
+        WritableMap writableMap = Arguments.createMap();
+        int state = IotChannelController.getInstance().getBleState();
+        writableMap.putString("state", "" + state);
+        promise.resolve(writableMap);
+    }
+
+    @Override
+    @ReactMethod
+    public void getTslAndAttrs(ReadableMap params, final Promise promise) {
+        final String productKey = ParamsValueUtils.getString(params, "productKey", "");
+        final String deviceKey = ParamsValueUtils.getString(params, "deviceKey", "");
+        final String gatewayPk = ParamsValueUtils.getString(params, "gatewayPk", "");
+        final String gatewayDk = ParamsValueUtils.getString(params, "gatewayDk", "");
+        final int filterType = ParamsValueUtils.getInt(params, "filterType", 0);
+
+        QuecDeviceService.INSTANCE.getProductTslAndDeviceBusinessAttributes(productKey, deviceKey, gatewayPk,
+                gatewayDk, null, null, filterType, new IDeviceTSLModelCallback() {
+                    @Override
+                    public void onResultCallback(List<QuecProductTSLPropertyModel<?>> list) {
+                        WritableMap writableMap = Arguments.createMap();
+                        try {
+                            if (list != null && !list.isEmpty()) {
+                                String jsonBack = QuecGsonUtil.INSTANCE.gsonString(list);
+                                int startIndex = 0;
+                                int maxLength = 1000;
+                                while (startIndex < jsonBack.length()) {
+                                    int endIndex = Math.min(startIndex + maxLength, jsonBack.length());
+                                    QLog.i(TAG, "原生->js 物模型分段打印==" + jsonBack.substring(startIndex, endIndex));
+                                    startIndex += maxLength;
+                                }
+                            }
+
+
+                            JSONArray jsonArray = new JSONArray(QuecGsonUtil.INSTANCE.gsonString(list));
+                            WritableArray writableArray = ReactNativeJson.convertJsonToArray(jsonArray);
+                            writableMap.putArray("data", writableArray);
+                            promise.resolve(writableMap);
+                        } catch (JSONException e) {
+                            QLog.e(TAG, "获取物模型失败-json解析异常");
+                            promise.reject(ErrorCode.ERROR_CODE_JSON_EXCEPTION, e.getLocalizedMessage());
+                            QLog.e(TAG, e);
+                        }
+                    }
+
+                    @Override
+                    public void onFail(Throwable throwable) {
+                        QLog.e(TAG, "获取物模型失败-异常: " + throwable);
+                        promise.reject(ErrorCode.ERROR_CODE_REQUEST_FAIL, throwable);
+                    }
+                });
+    }
+
+    @Override
+    @ReactMethod
+    public void readDpsWithMode(ReadableArray dps, int mode, final Promise promise) {
+        deviceClient.readDps(getData(dps, promise), getDataSendMode(mode), getSimpleCallback(promise));
+    }
+
+    @Override
+    @ReactMethod
+    public void writeDpsWithMode(ReadableArray dps, int mode, final Promise promise) {
+        deviceClient.writeDps(getData(dps, promise), getDataSendMode(mode), getSimpleCallback(promise));
+    }
+
+    @Override
+    @ReactMethod
+    public void getOnlineState(Promise promise) {
+        WritableMap writableMap = Arguments.createMap();
+        int state = deviceClient.getConnectState();
+        QLog.d("QuecRNDeviceModule", "onlineState " + state);
+        writableMap.putString("onlineState", "" + state);
+        promise.resolve(writableMap);
+    }
+
+    @Override
+    @ReactMethod
+    public void readDps(ReadableArray dps, final Promise promise) {
+        deviceClient.readDps(getData(dps, promise), getSimpleCallback(promise));
+    }
+
+    @Override
+    @ReactMethod
+    public void writeDps(ReadableArray dps, final Promise promise) {
+        deviceClient.writeDps(getData(dps, promise), getSimpleCallback(promise));
+    }
+
+    @Override
+    @ReactMethod
+    public void writeTransparent(String data, int mode, ReadableMap extraData, Promise promise) {
+        byte[] sendData;
+        try {
+            sendData = Base64.decode(data, Base64.DEFAULT);
+        } catch (Exception e) {
+            QLog.e(TAG, e);
+            promise.reject("-1", e);
+            return;
+        }
+        deviceClient.writeTransparent(sendData, getSimpleCallback(promise));
+    }
+
+    @Override
+    @ReactMethod
+    public void connectChannel(int mode) {
+        deviceClient.connectWithMode(getDataSendMode(mode));
+
+    }
+
+    @Override
+    @ReactMethod
+    public void disconnectChannel(int type) {
+        switch (type) {
+            case 1:
+                deviceClient.disconnectWithType(QuecIotChannelType.QuecIotChannelTypeWifi);
+                break;
+            case 2:
+                deviceClient.disconnectWithType(QuecIotChannelType.QuecIotChannelTypeWS);
+                break;
+            case 3:
+                deviceClient.disconnectWithType(QuecIotChannelType.QuecIotChannelTypeBLE);
+                break;
+            case 4:
+                deviceClient.disconnectWithType(QuecIotChannelType.QuecIotChannelTypeMatter);
+                break;
+            default:
+                deviceClient.disconnectWithType(QuecIotChannelType.QuecIotChannelTypeUnknown);
+                break;
+        }
+    }
+
+    /**
+     * 获取websocket是否登录成功
+     *
+     * @param isLoginCallback Func 接受是否登录websocket回调  已登录成功 true  登录失败  false
+     * @available: 1.0.0
+     * @platform: all
+     */
+    @Override
+    @ReactMethod
+    public void isWebSocketLoginCallback(Callback isLoginCallback) {
+        boolean result = WebSocketServiceLocater.getService(IWebSocketService.class).isWebSocketLoginCallback();
+        isLoginCallback.invoke(result);
+    }
+
+    /**
+     * 订阅设备
+     *
+     * @param list 订阅设备列表，订阅结果QuecDeviceServiceWebSocketDelegate返回
+     *             [
+     *             {
+     *             "deviceKey": "1234567890",
+     *             "messageType": [
+     *             "ONLINE"
+     *             ],
+     *             "productKey": "p12345"
+     *             },
+     *             {
+     *             "deviceKey": "1234567890",
+     *             "messageType": [
+     *             "ONLINE",
+     *             "STATUS"
+     *             ],
+     *             "productKey": "p12345"
+     *             }
+     *             ]
+     * @available: 1.0.0
+     * @platform: all
+     */
+    @Override
+    @ReactMethod
+    public void subscribeDevicesWithList(ReadableArray list) {
+        if (list != null && list.size() > 0) {
+            for (int i = 0; i < list.size(); i++) {
+                ReadableMap map = list.getMap(i);
+                String productKey = ParamsValueUtils.getString(map, "productKey", "");
+                String deviceKey = ParamsValueUtils.getString(map, "deviceKey", "");
+                WebSocketServiceLocater.getService(IWebSocketService.class).subscribeDevice(deviceKey, productKey);
+            }
+        }
+    }
+
+    /**
+     * 取消订阅设备
+     *
+     * @param list 取消订阅设备列表，取消订阅结果QuecDeviceServiceWebSocketDelegate返回
+     *             [
+     *             {
+     *             "deviceKey": "1234567890",
+     *             "productKey": "p12345"
+     *             },
+     *             {
+     *             "deviceKey": "1234567890",
+     *             "productKey": "p12345"
+     *             }
+     *             ]
+     * @available: 1.0.0
+     * @platform: all
+     */
+    @Override
+    @ReactMethod
+    public void unSubscribeDevicesWithList(ReadableArray list) {
+        if (list != null && list.size() > 0) {
+            for (int i = 0; i < list.size(); i++) {
+                ReadableMap map = list.getMap(i);
+                String productKey = ParamsValueUtils.getString(map, "productKey", "");
+                String deviceKey = ParamsValueUtils.getString(map, "deviceKey", "");
+                WebSocketServiceLocater.getService(IWebSocketService.class).unsubscribeDevice(deviceKey, productKey);
+            }
+        }
+    }
+
+    /**
+     * 获取设备业务属性值
+     *
+     * @param params 发送数据，需要在delegate的websocketDidOpen回调之后才能调用
+     *               透传
+     *               {
+     *               "cmd": "send",
+     *               "data": {
+     *               "cacheTime": 3600,
+     *               "dataFormat": "Text",
+     *               "deviceKey": "866123456789015",
+     *               "isCache": true,
+     *               "productKey": "p12345",
+     *               "raw": "123456",
+     *               "type": "RAW"
+     *               }
+     *               }
+     *               物模型
+     *               {
+     *               "cmd": "send",
+     *               "data": {
+     *               "deviceKey": "1234567890",
+     *               "kv": "[{\"id\":5,\"name\":\"openapi\",\"type\":\"BOOL\",\"value\":\"true\"}]",
+     *               "productKey": "p12345",
+     *               "type": "WRITE-ATTR"
+     *               }
+     *               }
+     * @available: 1.0.0
+     * @platform: all
+     */
+    @Override
+    @ReactMethod
+    public void sendDataToDeviceByWebSocketWithDataDict(ReadableMap params) {
+        QLog.d(TAG, "sendDataToDeviceByWebSocketWithDataDict");
+        if (params.hasKey("data")) {
+
+            try {
+                String info = new JSONObject(params.toString()).optString("NativeMap");
+                if (!TextUtils.isEmpty(info)) {
+                    WsManager.getInstance().sendMessage(info);
+                } else {
+                    WsManager.getInstance().sendMessage(params.toString());
+                }
+            } catch (Exception e) {
+                QLog.e(TAG, e);
+            }
+        }
+    }
+
+    /**
+     * 获取设备列表
+     *
+     * @param pageNumber number 页码
+     * @param pageSize   number 页大小
+     * @param promise    promise 执行回调
+     *                   callback  {"data": {"list" : [], "total" : 12}}
+     * @available: 1.0.0
+     * @platform: all
+     */
+    @Override
+    @ReactMethod
+    public void getDeviceListWithPageNumber(int pageNumber, int pageSize, final Promise promise) {
+        String uid = MmkvManager.getInstance().get(QuecMainConstant.MMKV_KEY_UID, "");
+        if (!NetUtils.isNetworkConnected(getReactApplicationContext())) {
+            String cachData = QuecCacheDataUtils.getUserDeviceListCacheData(uid);
+            if (!TextUtils.isEmpty(cachData)) {
+                List<DeviceModel> dataList = QuecGsonUtil.INSTANCE.gsonTolist(cachData, DeviceModel.class);
+                QuecPageResponse<DeviceModel> response = new QuecPageResponse<>();
+                response.setList(dataList);
+                response.setPageNum(pageNumber);
+                response.setPageSize(pageSize);
+                QuecResult<QuecPageResponse<DeviceModel>> result = new QuecResult<>(true, response,
+                        QuecResult.SUCCESS_CODE);
+                String resultStr = QuecGsonUtil.INSTANCE.gsonString(result);
+                ResponseUtils.handlerResponse(promise, resultStr, viewModel);
+            }
+            return;
+        }
+
+        QuecDeviceListParamsModel paramsModel = new QuecDeviceListParamsModel();
+        paramsModel.setPageNumber(pageNumber);
+        paramsModel.setPageSize(pageSize);
+        QuecDeviceService.INSTANCE.getDeviceList(paramsModel, quecResult -> {
+            if (quecResult.isSuccess()) {
+                if (pageNumber <= 1) {
+                    deviceModelList.clear();
+                }
+                if (quecResult.getData() != null) {
+                    QuecPageResponse<QuecDeviceModel> response = quecResult.getData();
+                    if (response.getList() != null && !response.getList().isEmpty()) {
+                        if (response.getPageNum() <= 1) {
+                            deviceModelList.clear();
+                        }
+                        deviceModelList.addAll(response.getList());
+                        String json = QuecGsonUtil.INSTANCE.gsonString(deviceModelList);
+                        QuecCacheDataUtils.saveUserDeviceListData(QuecBaseApp.getInstance(), uid, json);
+                        checkDeviceList(response.getList());
+                    }
+                }
+            }
+            ResponseUtils.handlerResponse(promise, quecResult, viewModel);
+        });
+    }
+
+    /**
+     * 获取设备业务物模型属性值
+     *
+     * @param params  map
+     *                productKey  string  产品key
+     *                deviceKey   string   设备key
+     *                codeList   string  非必填  查询的属性标识符
+     *                gatewayDk string  网关设备的 Device Key
+     *                gatewayPk string  网关设备的 Product Key
+     *                和查询类型配合使用，如果查询多个属性，使用英文逗号分隔
+     *                type  string 非必填 查询类型
+     *                1 查询设备基础属性
+     *                2 查询物模型属性
+     *                3 查询定位信息
+     *                查询类型可以单选和多选，如果需要查询多个类型的属性值，使用英文逗号分隔
+     * @param promise promise 执行回调
+     * @available: 1.0.0
+     * @platform: all
+     */
+    @Override
+    @ReactMethod
+    public void getProductTSLWithProductKey(ReadableMap params, final Promise promise) {
+        if (processNoNetWork(promise)) {
+            return;
+        }
+        String productKey = ParamsValueUtils.getString(params, "productKey", "");
+        String deviceKey = ParamsValueUtils.getString(params, "deviceKey", "");
+        String codeStr = ParamsValueUtils.getString(params, "codeList", "");
+        String typeStr = ParamsValueUtils.getString(params, "type", "");
+        String gatewayPk = ParamsValueUtils.getString(params, "gatewayPk", "");
+        String gatewayDk = ParamsValueUtils.getString(params, "gatewayDk", "");
+
+        QuecDeviceService.INSTANCE.getProductTslAndDeviceBusinessAttributes(productKey, deviceKey, gatewayPk,
+                gatewayDk, codeStr, typeStr, new IDeviceTSLModelCallback() {
+                    @Override
+                    public void onResultCallback(List<QuecProductTSLPropertyModel<?>> list) {
+                        WritableMap writableMap = Arguments.createMap();
+                        try {
+                            JSONArray jsonArray = new JSONArray(QuecGsonUtil.INSTANCE.gsonString(list));
+                            WritableArray writableArray = ReactNativeJson.convertJsonToArray(jsonArray);
+                            writableMap.putArray("data", writableArray);
+                            promise.resolve(writableMap);
+                        } catch (JSONException e) {
+                            QLog.e(TAG, e);
+                            promise.reject(ErrorCode.ERROR_CODE_JSON_EXCEPTION, e);
+                        }
+                    }
+
+                    @Override
+                    public void onFail(Throwable throwable) {
+                        promise.reject(ErrorCode.ERROR_CODE_REQUEST_FAIL, throwable);
+                    }
+                });
+    }
+
+    @Override
+    @ReactMethod
+    public void getDeviceBusinessAttributesWithProductKey(ReadableMap map, final Promise promise) {
+        if (processNoNetWork(promise)) {
+            return;
+        }
+        String pk = ParamsValueUtils.getString(map, "productKey", "");
+        String dk = ParamsValueUtils.getString(map, "deviceKey", "");
+        String codeList = ParamsValueUtils.getString(map, "codeList", "");
+        String type = ParamsValueUtils.getString(map, "type", "");
+        String gatewayPk = ParamsValueUtils.getString(map, "gatewayPk", "");
+        String gatewayDk = ParamsValueUtils.getString(map, "gatewayDk", "");
+
+        QuecDeviceService.INSTANCE.getDeviceBusinessAttributes(pk, dk, gatewayPk, gatewayDk, codeList, type,
+                getCallback(promise));
+    }
+
+    /**
+     * 更改分享设备名称
+     *
+     * @param deviceName string   设备名称
+     * @param shareCode  string   分享码
+     * @param promise    promise 执行回调
+     * @available: 1.0.0
+     * @platform: all
+     */
+    @Override
+    @ReactMethod
+    public void updateDeviceNameByShareUserWithDeviceName(String deviceName, String shareCode, final Promise promise) {
+        if (processNoNetWork(promise)) {
+            return;
+        }
+        QuecDeviceShareService.INSTANCE.updateDeviceNameByShareUser(deviceName, shareCode, result -> {
+            if (ResponseUtils.handlerResponse(promise, result, viewModel)) {
+                updateHomeList();
+            }
+        });
+    }
+
+    /**
+     * 更改分享设备名称
+     *
+     * @param deviceName string   deviceName
+     * @param productKey string   product key
+     * @param deviceKey  string   deviceKey
+     * @param promise    promise 执行回调
+     * @available: 1.0.0
+     * @platform: all
+     */
+    @Override
+    @ReactMethod
+    public void updateDeviceName(String deviceName, String productKey, String deviceKey, final Promise promise) {
+        if (processNoNetWork(promise)) {
+            return;
+        }
+        QuecDeviceService.INSTANCE.updateDeviceName(deviceName, productKey, deviceKey, result -> {
+            if (ResponseUtils.handlerResponse(promise, result, viewModel)) {
+                updateHomeList();
+            }
+        });
+    }
+
+    /**
+     * 查询网关设备下子设备列表
+     *
+     * @param params  deviceKey string  必传  网关设备deviceKey
+     *                productKey string  必传 网关设备productKey
+     *                pageNumber number 必传 页码
+     *                pageSize number 必传 页大小
+     * @param promise promise 执行回调
+     *                callback  {"data": {"list" : [], "total" : 12}}
+     * @available: 1.0.0
+     * @platform: all
+     */
+    @Override
+    @ReactMethod
+    public void getGatewayDeviceChildListWithParams(ReadableMap params, final Promise promise) {
+        if (processNoNetWork(promise)) {
+            return;
+        }
+        String deviceKey = ParamsValueUtils.getString(params, "deviceKey", "");
+        String productKey = ParamsValueUtils.getString(params, "productKey", "");
+        int pageNumber = ParamsValueUtils.getInt(params, "pageNumber", -1);
+        int pageSize = ParamsValueUtils.getInt(params, "pageSize", -1);
+
+        QuecDeviceGroupService.INSTANCE.getGatewayDeviceChildList(deviceKey, productKey, pageNumber, pageSize,
+                getCallback(promise));
+    }
+
+    /**
+     * 设备解绑
+     *
+     * @param deviceKey  string  device key
+     * @param productKey string  product key
+     * @param promise    promise 执行回调
+     * @available: 1.0.0
+     * @platform: all
+     */
+    @Override
+    @ReactMethod
+    public void unbindDeviceWithDeviceKey(final String deviceKey, final String productKey, final Promise promise) {
+        if (processNoNetWork(promise)) {
+            return;
+        }
+        QuecDeviceService.INSTANCE.unbindDevice(deviceKey, productKey, false, null, null, result -> {
+            if (ResponseUtils.handlerResponse(promise, result, viewModel)) {
+                unbindDeviceAndUpDateHomeList(channelId);
+                //解绑设备后，ipc隐私协议要重置
+                IpcUtil.savePrivacyState(productKey, deviceKey, false);
+                //解绑设备后，ipc视频、截图文件清理
+                IpcUtil.clearIpcVideoPhotoMMKV(productKey, deviceKey);
+            }
+        });
+    }
+
+    /**
+     * 设备解绑
+     *
+     * @param shareCode string  分享码
+     * @param promise   promise 执行回调
+     * @available: 1.0.0
+     * @platform: all
+     */
+    @Override
+    @ReactMethod
+    public void unShareDeviceByShareUserWithShareCode(String shareCode, final Promise promise) {
+        if (processNoNetWork(promise)) {
+            return;
+        }
+        QuecDeviceShareService.INSTANCE.unShareDeviceByShareUser(shareCode, result -> {
+            if (ResponseUtils.handlerResponse(promise, result, viewModel)) {
+                unbindDeviceAndUpDateHomeList(channelId);
+            }
+        });
+    }
+
+    @Override
+    @ReactMethod
+    public void unShareDeviceByShareUserWithShareCodeIpc(final String pk, final String dk, String shareCode,
+                                                         final Promise promise) {
+        if (processNoNetWork(promise)) {
+            return;
+        }
+        QuecDeviceShareService.INSTANCE.unShareDeviceByShareUser(shareCode, result -> {
+            if (ResponseUtils.handlerResponse(promise, result, viewModel)) {
+                unbindDeviceAndUpDateHomeList(channelId);
+                //解绑设备后，ipc隐私协议同意要重置
+                IpcUtil.savePrivacyState(pk, dk, false);
+                //解绑设备后，ipc视频、截图文件清理
+                IpcUtil.clearIpcVideoPhotoMMKV(pk, dk);
+            }
+        });
+    }
+
+    @Override
+    @ReactMethod
+    public void subscribeDevice(String pk, String dk) {
+        String channelId = getChannelId(pk, dk);
+        QLog.d(TAG, "subscribeDevice:channelId=" + channelId);
+        otherChannelIds.add(channelId);
+        WebSocketServiceLocater.getService(IWebSocketService.class).subscribeDevice(dk, pk);
+    }
+
+    @Override
+    @ReactMethod
+    public void unSubscribeDevice(String pk, String dk) {
+        String channelId = getChannelId(pk, dk);
+        QLog.d(TAG, "unSubscribeDevice:channelId=" + channelId);
+        otherChannelIds.remove(channelId);
+        WebSocketServiceLocater.getService(IWebSocketService.class).unsubscribeDevice(dk, pk);
+    }
+
+    @Override
+    @ReactMethod
+    public void deviceAssociationWithList(ReadableArray list, ReadableMap master, String fid, Promise promise) {
+        if (processNoNetWork(promise)) {
+            return;
+        }
+        ArrayList<QuecDeviceModel> slaveDTOS = new ArrayList<>();
+        QuecDeviceModel masterDTO = new QuecDeviceModel();
+        String pk = ParamsValueUtils.getString(master, PRODUCT_KEY_NAME, "");
+        String dk = ParamsValueUtils.getString(master, DEVICE_KEY_NAME, "");
+        masterDTO.setDeviceKey(dk);
+        masterDTO.setProductKey(pk);
+
+        if (list != null && list.size() > 0) {
+            try {
+                JSONArray jsonArray = QuecReadableMapUtil.convertArrayToJson(list);
+                for (int i = 0; i < jsonArray.length(); i++) {
+                    JSONObject jsonObject = jsonArray.optJSONObject(i);
+                    String slavePk = jsonObject.optString(PRODUCT_KEY_NAME, "");
+                    String slaveDk = jsonObject.optString(DEVICE_KEY_NAME, "");
+                    QuecDeviceModel slaveDTO = new QuecDeviceModel();
+                    slaveDTO.setProductKey(slavePk);
+                    slaveDTO.setDeviceKey(slaveDk);
+                    slaveDTOS.add(slaveDTO);
+                }
+            } catch (JSONException e) {
+                QLog.e(TAG, e.toString());
+            }
+        }
+
+        QuecDeviceAssociateService.INSTANCE.deviceAssociation(slaveDTOS, masterDTO, getCallback(promise));
+    }
+
+    @Override
+    @ReactMethod
+    public void deviceAssociation(ReadableMap master, String fid, String codeList, Promise promise) {
+        if (processNoNetWork(promise)) {
+            return;
+        }
+        String pk = ParamsValueUtils.getString(master, PRODUCT_KEY_NAME, "");
+        String dk = ParamsValueUtils.getString(master, DEVICE_KEY_NAME, "");
+
+        QuecDeviceModel model = new QuecDeviceModel();
+        model.setProductKey(pk);
+        model.setDeviceKey(dk);
+        QuecDeviceAssociateService.INSTANCE.getDeviceAssociationInfo(model, codeList, getCallback(promise));
+    }
+
+    @Override
+    @ReactMethod
+    public void deviceDisassociation(ReadableMap device, String fid, Promise promise) {
+        if (processNoNetWork(promise)) {
+            return;
+        }
+        String pk = ParamsValueUtils.getString(device, PRODUCT_KEY_NAME, "");
+        String dk = ParamsValueUtils.getString(device, DEVICE_KEY_NAME, "");
+
+        QuecDeviceModel bean = new QuecDeviceModel();
+        bean.setProductKey(pk);
+        bean.setDeviceKey(dk);
+        bean.setFid(fid);
+
+        QuecDeviceAssociateService.INSTANCE.deviceDisassociation(bean, getCallback(promise));
+    }
+
+    @Override
+    @ReactMethod
+    public void deviceAssociationConfig(String pk, Promise promise) {
+        if (processNoNetWork(promise)) {
+            return;
+        }
+
+        QuecDeviceAssociateService.INSTANCE.deviceAssociationConfig(pk, getCallback(promise));
+    }
+
+    @ReactMethod
+    @Override
+    public void getDeviceOnlineState(String pk, String dk, Promise promise) {
+        WritableMap writableMap = Arguments.createMap();
+        String channelId = pk + "_" + dk;
+        int state = IotChannelController.getInstance().getOnlineState(channelId);
+        QLog.d("QuecRNDeviceModule", "onlineState " + state);
+        writableMap.putString("onlineState", "" + state);
+        promise.resolve(writableMap);
+    }
+
+    //获取设备属性图表列表
+    @ReactMethod
+    @Override
+    public void getPropertyChartListWithParams(ReadableMap map, final Promise promise) {
+        if (processNoNetWork(promise)) {
+            return;
+        }
+        String pk = ParamsValueUtils.getString(map, "productKey", "");
+        String dk = ParamsValueUtils.getString(map, "deviceKey", "");
+        String attributeCode = ParamsValueUtils.getString(map, "attributeCode", "");
+        int countType = ParamsValueUtils.getInt(map, "countType", -1);
+        int timeGranularity = ParamsValueUtils.getInt(map, "timeGranularity", -1);
+        double startTimestamp = ParamsValueUtils.getDouble(map, "startTimestamp", 0);
+        double endTimestamp = ParamsValueUtils.getDouble(map, "endTimestamp", 0);
+
+        QuecDeviceStatisticsService.INSTANCE.getPropertyChartList(pk, dk, (long) startTimestamp, (long) endTimestamp,
+                attributeCode, null, null, countType, timeGranularity, result -> {
+                    if (!result.isSuccess()) {
+                        ResponseUtils.handlerError(promise, result.getCode(), result.getMsg(), viewModel);
+                        return;
+                    }
+
+                    try {
+                        WritableMap writableMap = Arguments.createMap();
+                        JSONObject obj =
+                                new JSONObject(QuecGsonUtil.INSTANCE.gsonString(new ResponseUtils.Content(result.getData())));
+                        JSONArray jarray = obj.getJSONArray("data");
+                        WritableArray wArray = Arguments.createArray();
+                        for (int i = 0; i < jarray.length(); i++) {
+                            JSONObject jobj = (JSONObject) jarray.get(i);
+                            WritableMap child = Arguments.createMap();
+                            String useCode = jobj.optString("propertyCode", "");
+                            if (TextUtils.isEmpty(useCode) || "null".equals(useCode)) {
+                                child.putNull("propertyCode");
+                                child.putNull("yaxisData");
+                                child.putNull("xaxisData");
+                            } else {
+                                JSONArray jarray11 = jobj.getJSONArray("yaxisData");
+                                JSONArray jarray22 = jobj.getJSONArray("xaxisData");
+                                WritableArray wArray11 = Arguments.createArray();
+                                WritableArray wArray22 = Arguments.createArray();
+                                for (int x = 0; x < jarray11.length(); x++) {
+                                    double num = jarray11.getDouble(x);
+                                    wArray11.pushDouble(num);
+                                }
+                                for (int y = 0; y < jarray22.length(); y++) {
+                                    String date = jarray22.getString(y);
+                                    wArray22.pushString(date);
+                                }
+                                child.putString("propertyCode", jobj.optString("propertyCode", ""));
+                                child.putArray("yaxisData", wArray11);
+                                child.putArray("xaxisData", wArray22);
+                            }
+                            wArray.pushMap(child);
+                        }
+                        writableMap.putArray("data", wArray);
+                        promise.resolve(writableMap);
+                    } catch (Exception e) {
+                        QLog.i(TAG, "---catch property  catch property  catch property---");
+                        QLog.e(TAG, e);
+                        WritableMap writableMap = Arguments.createMap();
+                        WritableArray wArray = Arguments.createArray();
+                        WritableMap child = Arguments.createMap();
+                        WritableArray wArray11 = Arguments.createArray();
+                        WritableArray wArray22 = Arguments.createArray();
+                        child.putArray("yaxisData", wArray11);
+                        child.putArray("xaxisData", wArray22);
+                        wArray.pushMap(child);
+                        writableMap.putArray("data", wArray);
+                        promise.resolve(writableMap);
+                    }
+                });
+    }
+
+    //分享人查询设备的被分享人列表
+    @ReactMethod
+    @Override
+    public void getDeviceShareUserListWithDeviceKey(String dk, String pk, final Promise promise) {
+        if (processNoNetWork(promise)) {
+            return;
+        }
+        QuecDeviceShareService.INSTANCE.getDeviceShareUserList(dk, pk, getCallback(promise));
+    }
+
+    //分享人设置分享信息
+    @ReactMethod
+    @Override
+    public void setShareInfoByOwnerWithDeviceKey(ReadableMap map, final Promise promise) {
+        if (processNoNetWork(promise)) {
+            return;
+        }
+        String dk = ParamsValueUtils.getString(map, "deviceKey", "");
+        Double acceptingExpireTime = ParamsValueUtils.getDouble(map, "acceptingExpireTime", 0.0);
+        String pk = ParamsValueUtils.getString(map, "productKey", "");
+        int coverMark = ParamsValueUtils.getInt(map, "coverMark", 0);
+        long sharingExpireAt = 0L;
+        QuecDeviceShareService.INSTANCE.setShareInfoByOwner(dk, pk, acceptingExpireTime.longValue(), coverMark, false
+                , sharingExpireAt, getCallback(promise));
+    }
+
+    //分享人取消分享
+    @ReactMethod
+    @Override
+    public void unShareDeviceByOwnerWithShareCode(String shareCode, final Promise promise) {
+        if (processNoNetWork(promise)) {
+            return;
+        }
+        QuecDeviceShareService.INSTANCE.unShareDeviceByOwner(shareCode, getCallback(promise));
+    }
+
+    //获取设备历史轨迹
+    @ReactMethod
+    @Override
+    public void getLocationHistoryWithParams(ReadableMap map, final Promise promise) {
+        if (processNoNetWork(promise)) {
+            return;
+        }
+        String pk = ParamsValueUtils.getString(map, "productKey", "");
+        String dk = ParamsValueUtils.getString(map, "deviceKey", "");
+        double startTimestamp = ParamsValueUtils.getDouble(map, "startTimestamp", 0);
+        double endTimestamp = ParamsValueUtils.getDouble(map, "endTimestamp", 0);
+        String locateTypes = ParamsValueUtils.getString(map, "locateTypes", "");
+
+        QuecDeviceStatisticsService.INSTANCE.getLocationHistory(pk, dk, (long) startTimestamp, (long) endTimestamp,
+                null, null, locateTypes, getCallback(promise));
+    }
+
+    /**
+     * WebSocket 已打开事件
+     *
+     * @param object 事件数据 data = {"code":"this is code", @"message":" this is reason"}
+     *               reminder.data = {}
+     * @available: 1.0.0
+     * @platform: all
+     */
+    @Override
+    public void onWebSocketDidOpen(ReadableMap object) {
+        ReactApplicationContext context = getReactApplicationContext();
+        if (context != null && context.hasActiveCatalystInstance()) {
+            context.getJSModule(RCTDeviceEventEmitter.class).emit("onWebSocketDidOpen", object);
+        }
+    }
+
+    /**
+     * WebSocket 错误事件
+     *
+     * @param object 事件数据 data = {"code":"this is code", @"message":" this is reason"}
+     * @available: 1.0.0
+     * @platform: all
+     */
+    @Override
+    public void onWebSocketDidError(ReadableMap object) {
+        ReactApplicationContext context = getReactApplicationContext();
+        if (context != null && context.hasActiveCatalystInstance()) {
+            context.getJSModule(RCTDeviceEventEmitter.class).emit("onWebSocketDidError", object);
+        }
+    }
+
+    /**
+     * WebSocket 消息事件
+     *
+     * @param object 事件数据
+     *               object.data = {
+     *               "cmd": "message",
+     *               "data": {
+     *               "createdAt": 1609316592000,
+     *               "data": {
+     *               "value": 1
+     *               },
+     *               "deviceKey": "866123456789015",
+     *               "productKey": "123456",
+     *               "ticket": "5f9924d171977c33bc5ad1b1",
+     *               "type": "ONLINE"
+     *               }
+     *               }
+     *               error
+     *               {
+     *               cmd = error;
+     *               data =     {
+     *               code = 4010;
+     *               msg = "user not logged in";
+     *               reqMsg = "";
+     *               };
+     * @available: 1.0.0
+     * @platform: all
+     */
+    @Override
+    public void onWebSocketDidReceiveMessage(ReadableMap object) {
+        QLog.d(TAG, "onWebSocketDidReceiveMessage");
+        ReactApplicationContext context = getReactApplicationContext();
+        if (context != null && context.hasActiveCatalystInstance()) {
+            context.getJSModule(RCTDeviceEventEmitter.class).emit("onWebSocketDidReceiveMessage", object);
+        }
+    }
+
+    @Override
+    public void deviceAssociationSelected(ReadableArray list) {
+        WritableMap writableMap = Arguments.createMap();
+        writableMap.putArray("list", list);
+        ReactApplicationContext context = getReactApplicationContext();
+        if (context != null && context.hasActiveCatalystInstance()) {
+            context.getJSModule(RCTDeviceEventEmitter.class).emit("deviceAssociationSelected", writableMap);
+        }
+    }
+
+    @Override
+    public void onDeviceStatusUpdate(ReadableMap object) {
+        try {
+            latch.await(); // 等待初始化完成
+            ReactApplicationContext context = getReactApplicationContext();
+            if (context != null && context.hasActiveCatalystInstance()) {
+                context.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class).emit("onDeviceStatusUpdate"
+                        , object);
+            }
+        } catch (InterruptedException e) {
+            QLog.e(TAG, "onDeviceStatusUpdate error: " + e);
+        }
+    }
+
+    @NonNull
+    @Override
+    public String getName() {
+        return "QuecRNDeviceModule";
+    }
+
+    public void sendConnectingStateEvent(int state) {
+        QLog.i(TAG, "onConnectingState  " + state);
+        WritableMap map = Arguments.createMap();
+        map.putInt("connectingState", state);
+        onDeviceConnectingState(map);
+    }
+
+    private void initData() {
+        QLog.i(TAG, "reactnativeModule init");
+        String json = MmkvManager.getInstance().get(Constants.QUEC_DEVICE_MODEL, "");
+
+        if (TextUtils.isEmpty(json)) {
+            return;
+        }
+        QuecDeviceModel model = new Gson().fromJson(json, QuecDeviceModel.class);
+        updateDeviceModel(model);
+        //如果设备未连接，自动连接
+        if (deviceClient.getConnectState() == 0) {
+            deviceClient.connect();
+        }
+    }
+
+    private void updateDeviceModel(QuecDeviceModel deviceModel) {
+        QLog.d(TAG, "updateDeviceModel::" + QuecGsonUtil.INSTANCE.gsonString(deviceModel));
+        if (deviceModel == null || TextUtils.isEmpty(deviceModel.getDeviceKey()) || TextUtils.isEmpty(deviceModel.getProductKey())) {
+            return;
+        }
+        this.deviceModel = deviceModel;
+        this.deviceClient.removeListener(listener);
+        this.deviceClient = QuecDeviceClient.Companion.initWithDevice(deviceModel);
+        this.deviceClient.addListener(listener);
+
+        channelId = deviceModel.getChannelId();
+        QLog.i(TAG, "channelId===" + channelId);
+    }
+
+    /**
+     * 初始化 注册监听上行数据 事件
+     */
+//    private void initIotChannelEvent() {
+//        IotChannelController.getInstance().setListener(listener);
+//    }
+    @Subscribe(threadMode = ThreadMode.MAIN)
+    public void onEvent(Object main) {
+//		QLog.d(TAG, "----------------------module js event--------------------");
+        QLog.d(TAG, "onEvent::" + QuecGsonUtil.INSTANCE.gsonString(main));
+        if (main instanceof SocketEvent) {
+            SocketEvent socketEvent = (SocketEvent) main;
+            String socketType = socketEvent.getType();
+            switch (socketType) {
+                case EventType.EVENT_TYPE_LOGIN_SUCCESS:
+                    //"data":{"code":1,"msg":"succ"}}
+                    QLog.i(TAG, "login success--:" + socketEvent.getData());
+                    try {
+                        JSONObject obj = new JSONObject(socketEvent.getData());
+                        WritableMap writableMap = Arguments.createMap();
+                        writableMap.putInt("code", obj.getInt("code"));
+                        writableMap.putString("msg", obj.getString("msg"));
+                        WritableMap child = Arguments.createMap();
+                        child.putMap("data", writableMap);
+                        onWebSocketDidOpen(child);
+                    } catch (Exception e) {
+                        QLog.e(TAG, e.toString());
+                    }
+                    break;
+                case EventType.EVENT_TYPE_WEBSOCKET_ERROR:
+                    try {
+                        WritableMap writableMap = Arguments.createMap();
+                        writableMap.putString("code", socketEvent.getType());
+                        writableMap.putString("message", socketEvent.getData());
+                        WritableMap child = Arguments.createMap();
+                        child.putMap("data", writableMap);
+                        onWebSocketDidError(child);
+                    } catch (Exception e) {
+                        QLog.e(TAG, e.toString());
+                    }
+                    break;
+            }
+        } else if (main instanceof SuccessEventContent) {
+            SuccessEventContent successEventContent = (SuccessEventContent) main;
+            try {
+                JSONObject obj = new JSONObject(successEventContent.getCmd_data());
+                WritableMap writableMap = ResponseUtils.getMapForHandlerJSONObject(obj);
+                String cmd = obj.getString("cmd");
+                writableMap.putString("cmd", cmd);
+                onWebSocketDidReceiveMessage(writableMap);
+            } catch (Exception e) {
+                QLog.e(TAG, e.toString());
+            }
+        } else if (main instanceof String) {
+            if ("close_panel".equals(main)) {
+                QLog.i("close device module");
+//                EventBus.getDefault().unregister(this);
+            }
+        } else if (main instanceof QuecIotDataPointsModel) {
+            QuecIotDataPointsModel model = (QuecIotDataPointsModel) main;
+            String receiveChannelId = model.pk + "_" + model.dk;
+            QLog.d(TAG, "receiveChannelId=" + receiveChannelId + ",channelId=" + channelId);
+            if (TextUtils.isEmpty(receiveChannelId) || TextUtils.isEmpty(channelId)) return;
+            if (channelId.equalsIgnoreCase(receiveChannelId) || otherChannelIds.contains(receiveChannelId)) {
+                if (model.action == QuecIotDataPointsModel.QuecIotDataPointAction.QuecIotDataPointActionVerified) {
+                    dealWithVerified();
+                }
+                AnalysisChannelDataUtils.analysisChannelData(model, getReactApplicationContext());
+            }
+        } else if (main instanceof ChannelStateEvent) {
+            int state = ((ChannelStateEvent) main).getOnLineState();
+            String channelIdEve = ((ChannelStateEvent) main).getChannelId();
+            if (TextUtils.isEmpty(channelIdEve) || TextUtils.isEmpty(channelId)) return;
+            if (channelIdEve.equals(channelId) || otherChannelIds.contains(channelIdEve)) {
+                QLog.i("设备桥接收到设备列表--发来通道状态更新eventbus");
+                AnalysisChannelDataUtils.updateOnlineState(getReactApplicationContext(), state);
+            }
+        } else if (main instanceof QuecDeviceModelUpdateEvent) {//更新设备信息
+            QuecDeviceModelUpdateEvent event = (QuecDeviceModelUpdateEvent) main;
+            updateDeviceModel(event.getQuecDeviceModel());
+        } else if (main instanceof QuecSelectedDeviceEvent) {
+            String jsonStr = ((QuecSelectedDeviceEvent) main).getJsonDeviceListStr();
+            if (!TextUtils.isEmpty(jsonStr)) {
+                try {
+                    WritableArray writableArray = ResponseUtils.getWritableArray(jsonStr);
+                    deviceAssociationSelected(writableArray);
+                } catch (JSONException e) {
+                    QLog.e(TAG, e.toString());
+                }
+            }
+        }
+    }
+
+    /**
+     * 执行期间判断网络是否异常
+     *
+     * @return TRUE 异常 false 正常
+     */
+    private boolean processNoNetWork(Promise promise) {
+        if (!NetUtils.isNetworkConnected(getReactApplicationContext())) {
+            promise.reject(ErrorCode.ERROR_CODE_NETWORK_ABNORMAL,
+                    QuecBaseApp.getInstance().getString(com.quectel.ui.config.R.string.quec_error_code_default));
+            return true;
+        }
+        return false;
+    }
+
+    //通过pk,dk 获取设备详情
+    @ReactMethod
+    @Override
+    public void getDeviceInfoByDeviceKey(String dk, String pk, final Promise promise) {
+        if (processNoNetWork(promise)) {
+            return;
+        }
+        QuecDeviceService.INSTANCE.getDeviceInfoByDeviceKey(dk, pk, result -> {
+            if (result.isSuccess()) {
+                checkDevice(result.getData());
+            }
+            ResponseUtils.handlerResponse(promise, result, viewModel);
+        });
+    }
+
+    //获取设备属性数据列表
+    @ReactMethod
+    @Override
+    public void getPropertyDataListWithParams(ReadableMap map, final Promise promise) {
+        if (processNoNetWork(promise)) {
+            return;
+        }
+        String pk = ParamsValueUtils.getString(map, "productKey", "");
+        String dk = ParamsValueUtils.getString(map, "deviceKey", "");
+        String attributeCode = ParamsValueUtils.getString(map, "attributeCode", "");
+        double startTimestamp = ParamsValueUtils.getDouble(map, "startTimestamp", 0);
+        double endTimestamp = ParamsValueUtils.getDouble(map, "endTimestamp", 0);
+        int page = ParamsValueUtils.getInt(map, "pageNumber", -1);
+        int pageSize = ParamsValueUtils.getInt(map, "pageSize", -1);
+
+        QuecDeviceStatisticsService.INSTANCE.getPropertyDataList(pk, dk, (long) startTimestamp, (long) endTimestamp,
+                attributeCode, null, null, page, pageSize, getCallback(promise));
+    }
+
+    //获取设备属性环比统计数据
+    //callback  {"data": []}
+    @ReactMethod
+    @Override
+    public void getPropertyStatisticsWithParams(ReadableMap map, final Promise promise) {
+        if (processNoNetWork(promise)) {
+            return;
+        }
+        String pk = ParamsValueUtils.getString(map, "productKey", "");
+        String dk = ParamsValueUtils.getString(map, "deviceKey", "");
+        String attributeCode = ParamsValueUtils.getString(map, "attributeCode", "");
+        int countType = ParamsValueUtils.getInt(map, "countType", -1);
+        // int backNum = ParamsValueUtils.getInt(map, "backNum", -1);
+        double currentTimestamp = ParamsValueUtils.getDouble(map, "currentTimestamp", 0);
+        String gatewayDk = ParamsValueUtils.getString(map, "gatewayDk", "");
+        String gatewayPk = ParamsValueUtils.getString(map, "gatewayPk", "");
+        String timeGranularities = ParamsValueUtils.getString(map, "timeGranularities", "");
+        //  boolean  isCompare = ParamsValueUtils.getBoolean(map,"isCompare",false);
+
+        QuecDeviceStatisticsService.INSTANCE.getPropertyStatisticsPath(pk, dk, (long) currentTimestamp, attributeCode
+                , gatewayDk, gatewayPk, countType, timeGranularities, getCallback(promise));
+    }
+
+    //通过shareCode  获取设备详情
+    @ReactMethod
+    @Override
+    public void getDeviceInfoByShareCode(String shareCode, final Promise promise) {
+        if (processNoNetWork(promise)) {
+            return;
+        }
+        QuecDeviceShareService.INSTANCE.getDeviceInfoByShareCode(shareCode, result -> {
+            if (result.isSuccess()) {
+                checkDevice(result.getData());
+            }
+            ResponseUtils.handlerResponse(promise, result, viewModel);
+        });
+    }
+
+    //根据设备名称查询设备
+    @ReactMethod
+    @Override
+    public void getDeviceListByDeviceName(String deviceName, int pageNumber, int pageSize, final Promise promise) {
+        if (processNoNetWork(promise)) {
+            return;
+        }
+        QuecDeviceListParamsModel model = new QuecDeviceListParamsModel();
+        model.setDeviceName(deviceName);
+        QuecDeviceService.INSTANCE.getDeviceList(model, result -> {
+            if (result.isSuccess()) {
+                checkDeviceList(result.getData().getList());
+            }
+            ResponseUtils.handlerResponse(promise, result, viewModel);
+        });
+    }
+
+    @ReactMethod
+    @Override
+    public void bindDeviceBySerialNumber(String sn, String pk, String deviceName, final Promise promise) {
+        if (processNoNetWork(promise)) {
+            return;
+        }
+        QuecDeviceService.INSTANCE.bindDeviceWithSerialNumber(sn, pk, deviceName, getCallback(promise));
+    }
+
+    @ReactMethod
+    @Override
+    public void bindDeviceByAuthCode(ReadableMap map, final Promise promise) {
+        if (processNoNetWork(promise)) {
+            return;
+        }
+        String authCode = ParamsValueUtils.getString(map, "authCode", "");
+        String pk = ParamsValueUtils.getString(map, "productKey", "");
+        String dk = ParamsValueUtils.getString(map, "deviceKey", "");
+        String deviceName = ParamsValueUtils.getString(map, "deviceName", "");
+        QuecDeviceService.INSTANCE.bindWifiDeviceWithAuthCode(authCode, pk, dk, deviceName, 0, getCallback(promise));
+    }
+
+    @ReactMethod
+    @Override
+    public void bindDeviceByPSWAuthCode(ReadableMap map, final Promise promise) {
+        if (processNoNetWork(promise)) {
+            return;
+        }
+        String authCode = ParamsValueUtils.getString(map, "authCode", "");
+        String pk = ParamsValueUtils.getString(map, "pk", "");
+        String dk = ParamsValueUtils.getString(map, "dk", "");
+        String pwd = ParamsValueUtils.getString(map, "pwd", "");
+        DeviceServiceFactory.getInstance().getService(IDevService.class).bindDeviceByBlueTooth(authCode, pk, dk, pwd,
+                new IHttpCallBack() {
+                    @Override
+                    public void onSuccess(String result) {
+                        ResponseUtils.handlerResponse(promise, result, viewModel);
+                    }
+
+                    @Override
+                    public void onFail(Throwable e) {
+                        QLog.e(TAG, e);
+                    }
+                });
+    }
+
+    //查询设备升级计划
+    @ReactMethod
+    @Override
+    public void getFetchPlanWithProductKey(String pk, String dk, ReadableMap map, final Promise promise) {
+        if (processNoNetWork(promise)) {
+            return;
+        }
+        DeviceServiceFactory.getInstance().getService(IDevService.class).queryFetchPlan(pk, dk, new IHttpCallBack() {
+            @Override
+            public void onSuccess(String result) {
+                ResponseUtils.handlerResponse(promise, result, viewModel);
+            }
+
+            @Override
+            public void onFail(Throwable e) {
+                QLog.e(TAG, e);
+            }
+        });
+    }
+
+    //上报升级状态
+    @ReactMethod
+    @Override
+    public void reportDeviceUpgradeStatusWithProductKey(ReadableMap map, final Promise promise) {
+        if (processNoNetWork(promise)) {
+            return;
+        }
+        String productKey = ParamsValueUtils.getString(map, "productKey", "");
+        String deviceKey = ParamsValueUtils.getString(map, "deviceKey", "");
+        String componentNo = ParamsValueUtils.getString(map, "componentNo", "");
+        int reportStatus = ParamsValueUtils.getInt(map, "reportStatus", -1);
+        DeviceServiceFactory.getInstance().getService(IDevService.class).reportUpgradeStatus(productKey, deviceKey,
+                componentNo, reportStatus, new IHttpCallBack() {
+                    @Override
+                    public void onSuccess(String result) {
+                        ResponseUtils.handlerResponse(promise, result, viewModel);
+                    }
+
+                    @Override
+                    public void onFail(Throwable e) {
+                        QLog.e(TAG, e);
+                    }
+                });
+    }
+
+    /**
+     * 设备批量控制
+     * data 遵循tsl格式的json string [{"id":62,"value":99,"type":"INT","name":"温度(temp)"},{"id":63,"value":"true",
+     * "type":"BOOL","name":"开关机状态(powerstate)"}]
+     * deviceList 设备列表 [{"deviceKey":"", "productKey":""}]
+     * type   number   类型 1：透传 2：属性 3：服务
+     * dataFormat   number  数据类型 1：Hex 2：Text（当type为透传时，需要指定 dataFormat）
+     * cacheTime  number  非必传   缓存时间，单位为秒，缓存时间范围 1-7776000 秒，启用缓存时必须设置缓存时间
+     * isCache number 非必传  是否启用缓存 1：启用 2：不启用，默认不启用
+     * isCover number 非必传  是否覆盖之前发送的相同的命令 1：覆盖 2：不覆盖，默认不覆盖，启用缓存时此参数有效
+     */
+    @ReactMethod
+    @Override
+    public void sendDataToDevicesByHttpWithData(ReadableMap map, final Promise promise) {
+        if (processNoNetWork(promise)) {
+            return;
+        }
+        String data = ParamsValueUtils.getString(map, "data", "");
+        ReadableArray deviceList = map.getArray("deviceList");
+        int cacheTime = ParamsValueUtils.getInt(map, "cacheTime", -1);
+        int isCache = ParamsValueUtils.getInt(map, "isCache", -1);
+        int isCover = ParamsValueUtils.getInt(map, "isCover", -1);
+        int dataFormat = ParamsValueUtils.getInt(map, "dataFormat", -1);
+        int type = ParamsValueUtils.getInt(map, "type", -1);
+        List<QuecBatchControlDeviceModel> list = new ArrayList<>();
+        if (deviceList != null && deviceList.size() > 0) {
+            for (int i = 0; i < deviceList.size(); i++) {
+                ReadableMap mapa = deviceList.getMap(i);
+                String productKey = ParamsValueUtils.getString(mapa, "productKey", "");
+                String deviceKey = ParamsValueUtils.getString(mapa, "deviceKey", "");
+                QuecBatchControlDeviceModel adp = new QuecBatchControlDeviceModel(productKey, deviceKey, "", "");
+                list.add(adp);
+            }
+        }
+        QuecDeviceControlService.INSTANCE.sendDataToDevicesByHttp(data, list, type,
+                new QuecBatchControlExtraModel(cacheTime, dataFormat, isCache, isCover, -1), getCallback(promise));
+    }
+
+    /**
+     * 添加云端定时
+     *
+     * @param map     云端定时参数
+     * @param promise 请求回调
+     */
+    @ReactMethod
+    @Override
+    public void addCornJob(ReadableMap map, final Promise promise) {
+        if (processNoNetWork(promise)) {
+            return;
+        }
+        try {
+            JSONObject params = ReactNativeJson.convertMapToJson(map);
+            QuecCornJobModel timing = JsonUtils.fromJsonString(params.toString(), (new TypeToken<QuecCornJobModel>() {
+            }).getType());
+            QuecDeviceService.INSTANCE.addCornJob(timing, result -> {
+                if (result.isSuccess()) {
+                    WritableMap resultMap = Arguments.createMap();
+                    WritableMap rulerMap = Arguments.createMap();
+                    rulerMap.putString("ruleId", result.getData());
+                    resultMap.putMap("data", rulerMap);
+                    promise.resolve(resultMap);
+                } else {
+                    ResponseUtils.handlerError(promise, result.getCode(), result.getMsg(), viewModel);
+                }
+            });
+        } catch (JSONException e) {
+            QLog.e(TAG, "addCornJob error: " + e);
+            promise.reject(ErrorCode.ERROR_CODE_JSON_EXCEPTION, e);
+        }
+    }
+
+    /**
+     * 编辑云端定时
+     *
+     * @param map     云端定时参数
+     * @param promise 请求回调
+     */
+    @ReactMethod
+    @Override
+    public void setCronJob(ReadableMap map, final Promise promise) {
+        if (processNoNetWork(promise)) {
+            return;
+        }
+        try {
+            JSONObject params = ReactNativeJson.convertMapToJson(map);
+            QuecCornJobModel timing = JsonUtils.fromJsonString(params.toString(), (new TypeToken<QuecCornJobModel>() {
+            }).getType());
+            QuecDeviceService.INSTANCE.setCronJob(timing, getCallback(promise));
+        } catch (JSONException e) {
+            QLog.e(TAG, "setCronJob error: " + e);
+            promise.reject(ErrorCode.ERROR_CODE_JSON_EXCEPTION, e);
+        }
+    }
+
+    /**
+     * 查询设备下定时任务列表
+     *
+     * @param map     云端定时参数
+     * @param promise 请求回调
+     */
+    @ReactMethod
+    @Override
+    public void getCronJobList(ReadableMap map, final Promise promise) {
+        if (processNoNetWork(promise)) {
+            return;
+        }
+        try {
+            JSONObject params = ReactNativeJson.convertMapToJson(map);
+            CloudTimingList timingList = JsonUtils.fromJsonString(params.toString(), (new TypeToken<CloudTimingList>() {
+            }).getType());
+            QuecDeviceService.INSTANCE.getCronJobList(timingList.getDeviceKey(), timingList.getProductKey(),
+                    timingList.getType(), timingList.getPage(), timingList.getPageSize(), getCallback(promise));
+        } catch (JSONException e) {
+            QLog.e(TAG, "getCronJobList error: " + e);
+            promise.reject(ErrorCode.ERROR_CODE_JSON_EXCEPTION, e);
+        }
+    }
+
+    /**
+     * 查询定时任务详情
+     *
+     * @param ruleId  规则引擎 ID
+     * @param promise 请求回调
+     */
+    @ReactMethod
+    @Override
+    public void getCronJobInfo(String ruleId, final Promise promise) {
+        if (processNoNetWork(promise)) {
+            return;
+        }
+        QuecDeviceService.INSTANCE.getCronJobInfo(ruleId, getCallback(promise));
+    }
+
+    /**
+     * 批量删除定时任务
+     *
+     * @param map     删除云端定时参数
+     * @param promise 请求回调
+     */
+    @ReactMethod
+    @Override
+    public void batchDeleteCronJob(ReadableMap map, final Promise promise) {
+        if (processNoNetWork(promise)) {
+            return;
+        }
+        try {
+            JSONObject params = ReactNativeJson.convertMapToJson(map);
+            QLog.i(TAG, "params: " + params);
+            BatchDeleteCloudTiming deleteCloudTiming = JsonUtils.fromJsonString(params.toString(),
+                    (new TypeToken<BatchDeleteCloudTiming>() {
+                    }).getType());
+            QLog.i(TAG, "deleteCloudTiming: " + deleteCloudTiming.toString());
+            QuecDeviceService.INSTANCE.batchDeleteCornJob(deleteCloudTiming.getRuleIdList(), getCallback(promise));
+        } catch (JSONException e) {
+            QLog.e(TAG, "batchDeleteCronJob error: " + e);
+            promise.reject(ErrorCode.ERROR_CODE_JSON_EXCEPTION, e);
+        }
+    }
+
+    /**
+     * 查询产品下设备可以添加的最大定时任务数量
+     *
+     * @param productKey 产品PK
+     * @param promise    请求回调
+     */
+    @ReactMethod
+    @Override
+    public void getProductCornJobLimit(String productKey, final Promise promise) {
+        if (processNoNetWork(promise)) {
+            return;
+        }
+        QuecDeviceService.INSTANCE.getProductCornJobLimit(productKey, getCallback(promise));
+    }
+
+    @ReactMethod
+    @Override
+    public void openWebSocket() {
+        if (!EventBus.getDefault().isRegistered(QuecRNDeviceModule.this)) {
+            EventBus.getDefault().register(QuecRNDeviceModule.this);
+        }
+        WebSocketServiceLocater.getService(IWebSocketService.class).login();
+    }
+
+    @ReactMethod
+    @Override
+    public void closeWebSocket() {
+        if (EventBus.getDefault().isRegistered(QuecRNDeviceModule.this)) {
+            EventBus.getDefault().unregister(QuecRNDeviceModule.this);
+        }
+        WebSocketServiceLocater.getService(IWebSocketService.class).disconnect();
+    }
+
+    @ReactMethod
+    @Override
+    public void getProductTSLWithCacheByProductKey(ReadableMap param, final Promise promise) {
+        String pk = ParamsValueUtils.getString(param, "productKey", "");
+        DeviceServiceFactory.getInstance().getService(IDevService.class).getProductTSLWithCache(pk,
+                new IDeviceTSLCallBack() {
+                    @Override
+                    public void onSuccess(List<ModelBasic> list, List<TSLEvent> list1, List<TSLService> list2) {
+//                WritableArray modelBasicList = Arguments.createArray();
+//                WritableMap result = Arguments.createMap();
+//                result.putArray("data", modelBasicList);
+//                promise.resolve(result);
+//                String json = QuecGsonUtil.INSTANCE.gsonString(list);
+                        List<ModelBasic<?>> covertList = new ArrayList<>();
+                        for (ModelBasic data : list) {
+                            covertList.add(data);
+                        }
+                        WritableArray array = DataConvertUtils.getRNArrayByModelBasicList(covertList);
+                        WritableMap result = Arguments.createMap();
+                        result.putArray("data", array);
+                        promise.resolve(result);
+                    }
+
+                    @Override
+                    public void onFail(Throwable throwable) {
+                        promise.reject(ErrorCode.ERROR_CODE_REQUEST_FAIL, throwable);
+                    }
+                });
+    }
+
+    @Override
+    public void onDeviceConnectingState(ReadableMap object) {
+        waitInit(result -> {
+            ReactApplicationContext context = getReactApplicationContext();
+            if (context != null && context.hasActiveCatalystInstance()) {
+                context.getJSModule(RCTDeviceEventEmitter.class).emit("onDeviceConnectingState", object);
+            }
+        });
+    }
+
+    @Override
+    public void onDeviceOnlineState(ReadableMap object) {
+        waitInit(result -> {
+            QLog.i(TAG,
+                    "[" + Thread.currentThread().getName() + "] - send online state: " + object.getMap(Constants.DEVICE_PANEL_DEVICE_MODEL).getInt("onlineStatus"));
+            ReactApplicationContext context = getReactApplicationContext();
+            if (context != null && context.hasActiveCatalystInstance()) {
+                context.getJSModule(RCTDeviceEventEmitter.class).emit("onDeviceOnlineState", object);
+            }
+        });
+    }
+
+    @Override
+    public void onDeviceDpsUpdate(ReadableMap object) {
+    }
+
+    @Override
+    public void onDeviceInfoUpdate(ReadableMap object) {
+    }
+
+    //刷新首页列表信息
+    private void updateHomeList() {
+        //通知首页进行数据刷新
+        EventBus.getDefault().post(new RefreshDeviceListEvent());
+    }
+
+    //刷新首页列表信息
+    private void unbindDeviceAndUpDateHomeList(String channelId) {
+        //通知首页解绑设备并进行数据刷新
+        EventBus.getDefault().post(new RefreshUnbindDeviceEvent(channelId));
+    }
+
+    @Override
+    public void invalidate() {
+        super.invalidate();
+        QLog.i("QuecRNDeviceModule  invalidate");
+        if (EventBus.getDefault().isRegistered(QuecRNDeviceModule.this)) {
+            EventBus.getDefault().unregister(QuecRNDeviceModule.this);
+        }
+        deviceClient.removeListener(listener);
+        QuecDevicePanelServiceManager.getInstance().removeDeviceInfoEventCallback(deviceEventCallback);
+    }
+
+    @ReactMethod
+    @Override
+    public void listDeviceEvent(ReadableMap map, final Promise promise) {
+        if (processNoNetWork(promise)) {
+            return;
+        }
+
+        ReadableArray codeArray = map.getArray("codeList");
+        String productKey = ParamsValueUtils.getString(map, "productKey", "");
+        String deviceKey = ParamsValueUtils.getString(map, "deviceKey", "");
+        long startTime = Long.parseLong(ParamsValueUtils.getString(map, "startTime", "0"));
+        long endTime = Long.parseLong(ParamsValueUtils.getString(map, "endTime", "0"));
+        int page = ParamsValueUtils.getInt(map, "pageNumber", 1);
+        int pageSize = ParamsValueUtils.getInt(map, "pageSize", 10);
+        List<String> codeList = new ArrayList<>();
+        if (codeArray != null && codeArray.size() > 0) {
+            for (int i = 0; i < codeArray.size(); i++) {
+                String code = codeArray.getString(i);
+                codeList.add(code);
+            }
+        }
+
+        DeviceServiceFactory.getInstance().getService(IDevService.class).listDeviceEvent(codeList, productKey,
+                deviceKey, startTime, endTime, page, pageSize, new IHttpCallBack() {
+                    @Override
+                    public void onSuccess(String result) {
+                        ResponseUtils.handlerResponse(promise, result, viewModel);
+                    }
+
+                    @Override
+                    public void onFail(Throwable e) {
+                        QLog.e(TAG, e.toString());
+                    }
+                });
+    }
+
+    private String getChannelId(String pk, String dk) {
+        return pk + "_" + dk;
+    }
+
+    /**
+     * 设置离线提醒开关
+     *
+     * @param enableOfflineReminder 开关
+     * @param productKey            product key
+     * @param deviceKey             device key
+     * @param promise               返回值
+     */
+    @ReactMethod
+    @Override
+    public void setOfflineReminder(int enableOfflineReminder, String productKey, String deviceKey, Promise promise) {
+        QuecDeviceService.INSTANCE.setOfflineReminder(productKey, deviceKey, enableOfflineReminder,
+                getCallback(promise));
+    }
+
+    /**
+     * 离线提醒开关查询
+     *
+     * @param productKey product key
+     * @param deviceKey  device key
+     * @param promise    返回值
+     */
+    @ReactMethod
+    @Override
+    public void getOfflineReminderInfo(String productKey, String deviceKey, Promise promise) {
+        QuecDeviceService.INSTANCE.getOfflineReminder(productKey, deviceKey, getCallback(promise));
+    }
+
+    @ReactMethod
+    @Override
+    public void checkDeviceUpdatePlan(ReadableMap device, Promise promise) {
+        String productKey = device.getString("productKey");
+        String deviceKey = device.getString("deviceKey");
+        if (productKey == null || deviceKey == null) {
+            promise.reject("-9998", "productKey or deviceKey is null");
+            return;
+        }
+        QuecOtaManager.INSTANCE.checkVersion(productKey, deviceKey, result -> {
+            if (result.isSuccess()) {
+                if (result.getData() != null) {
+                    WritableMap writableMap = Arguments.createMap();
+                    writableMap.putBoolean("data", true);
+                    promise.resolve(writableMap);
+                } else {
+                    promise.reject("-9999", "There is no upgrade plan");
+                }
+            } else {
+                promise.reject(ErrorCode.ERROR_CODE_REQUEST_FAIL, new QuecError(result.getCode(), result.getMsg(),
+                        result.getSubCode()));
+            }
+        });
+    }
+
+    @ReactMethod
+    @Override
+    public void openDeviceOTAPage(String productKey, String deviceKey, Promise promise) {
+        if (processNoNetWork(promise)) {
+            QuecToastUtil.showS(com.quectel.ui.config.R.string.quec_error_code_default);
+            return;
+        }
+        QuecOtaManager.INSTANCE.checkVersion(productKey, deviceKey, result -> {
+            if (result.isSuccess()) {
+                if (result.getData() != null) {
+                    QuecOtaInfo model = result.getData();
+                    // 2跳转升级计划页面
+                    int deviceStatus = model.getDeviceStatus();
+                    long planId = model.getPlanId();
+                    Activity context = getCurrentActivity();
+                    if (context != null && !context.isFinishing()) {
+                        OtaUpgradeServiceManager.INSTANCE.jumpSingleDevice(getCurrentActivity(), deviceKey,
+                                productKey, deviceStatus, true, planId);
+                    }
+                } else {
+//                    QuecToastUtil.showS(R.string.quec_error_code_5557);
+                    Activity context = getCurrentActivity();
+                    if (context != null && !context.isFinishing()) {
+                        OtaUpgradeServiceManager.INSTANCE.jumpSingleDeviceVersion(context, deviceKey, productKey);
+                    }
+                }
+            } else {
+                checkResult(result);
+                QuecToastUtil.showS(result.getMsg());
+                promise.reject(ErrorCode.ERROR_CODE_REQUEST_FAIL, new QuecError(result.getCode(), result.getMsg(),
+                        result.getSubCode()));
+            }
+        });
+    }
+
+    @ReactMethod
+    @Override
+    public void getTimeDifferenceWithGMT(Promise promise) {
+        String timeZoneName = QuecTimeZoneUtil.getCurrentTimeZone(); //获取名字，如“GMT+08:00”
+        WritableMap writableMap = Arguments.createMap();
+        writableMap.putString("data", timeZoneName);
+        promise.resolve(writableMap);
+
+    }
+
+    @ReactMethod
+    @Override
+    public void getDeviceTimeZone(String pk, String dk, Promise promise) {
+        QuecDeviceService.INSTANCE.getDeviceTimeZone(pk, dk, getCallback(promise));
+    }
+
+    @ReactMethod
+    @Override
+    public void setDeviceTimeZone(String pk, String dk, String timezone, Promise promise) {
+        String timeZoneName = QuecTimeZoneUtil.getCurrentTimeZone(); //获取名字，如“GMT+08:00”
+        String timeZoneId = QuecTimeZoneUtil.getCurrentTimeZoneId();
+        QuecDeviceService.INSTANCE.setDeviceTimeZone(pk, dk, timeZoneName, timeZoneId, getCallback(promise));
+    }
+
+    @ReactMethod
+    @Override
+    public void getDeviceStateInfo(String productKey, String deviceKey, Promise promise) {
+        deviceClient.readDeviceStatusWithResult(result -> {
+            if (result.isSuccess()) {
+                QLog.i("设备返回的设备状态信息=" + QuecGsonUtil.INSTANCE.gsonString(result.getData()));
+                try {
+                    JSONObject obj = new JSONObject(QuecGsonUtil.INSTANCE.gsonString(result.getData()));
+                    WritableMap writableMap = ReactNativeJson.convertJsonToMap(obj);
+                    onDeviceStatusUpdate(writableMap);
+                } catch (JSONException e) {
+                    QLog.e(TAG, e);
+                }
+            } else {
+                promise.reject("-9999", "获取设备状态失败");
+            }
+        });
+    }
+
+
+    @ReactMethod
+    @Override
+    public void jumpDeviceWiFiListPage(String productKey, String deviceKey, String oldSsid, String signal_strength,
+                                       boolean supportOnlineWiFiScan, Promise promise) {
+        Activity context = getCurrentActivity();
+        QuecWifiSwitchUIServiceManager.getInstance().jumpToWifiList(context, productKey, deviceKey, oldSsid,
+                signal_strength, supportOnlineWiFiScan);
+        IotChannelController.getInstance().setWifiChangeListener((channelId, bean) -> {
+            try {
+                JSONObject obj = new JSONObject(QuecGsonUtil.INSTANCE.gsonString(bean));
+                WritableMap writableMap = ReactNativeJson.convertJsonToMap(obj);
+                onDeviceStatusUpdate(writableMap);
+            } catch (JSONException e) {
+                QLog.e(TAG, e);
+            }
+        });
+//        QuecToastUtil.showS("跳转设备wifi列表");
+    }
+
+
+    @ReactMethod
+    @Override
+    public void getProductDescription(String productKey, Promise promise) {
+        if (processNoNetWork(promise)) {
+            return;
+        }
+        QuecDeviceService.INSTANCE.getProductDescription(productKey, result -> {
+            if (result.isSuccess()) {
+                WritableMap writableMap = Arguments.createMap();
+                WritableMap dataMap = Arguments.createMap();
+                dataMap.putString("url", result.getData());
+                writableMap.putMap("data", dataMap);
+
+                promise.resolve(writableMap);
+            } else {
+                ResponseUtils.handlerResponse(promise, result, viewModel);
+            }
+        });
+    }
+
+    @ReactMethod
+    @Override
+    public void getFamilyDeviceList(int pageNumber, int pageSize, Promise promise) {
+        String fid = MmkvManager.getInstance().get("familyId", "");
+        QuecSmartHomeService.INSTANCE.getFamilyDeviceList(new QuecFamilyDeviceListParamsModel(fid, true, "",
+                pageNumber, pageSize, false, false, null, null), result -> {
+            if (result.isSuccess()) {
+                checkDeviceList(result.getData().getList());
+            }
+            ResponseUtils.handlerResponse(promise, result, viewModel);
+        });
+    }
+
+    @Override
+    @ReactMethod
+    public void timeZoneSync(String productKey, String deviceKey, Promise promise) {
+        if (deviceClient.getConnectState() > 0) {
+            deviceClient.timeZoneSync();
+            QLog.i(TAG, "时间同步成功");
+            WritableMap writableMap = Arguments.createMap();
+            promise.resolve(writableMap);
+        } else {
+            QLog.e("时间同步失败");
+            promise.reject(ErrorCode.ERROR_CODE_JSON_EXCEPTION, "时间同步失败：");
+        }
+    }
+
+    @Override
+    @ReactMethod
+    public void unbindlingPureBtDevice(String productKey, String deviceKey, boolean isInit, String random,
+                                       String pureBtResetCredentials, Promise promise) {
+        DeviceModel deviceModel = new DeviceModel();
+        deviceModel.setProductKey(productKey);
+        deviceModel.setDeviceKey(deviceKey);
+        QuecDeviceListServiceManager.getInstance().unBindDevice(Collections.singletonList(deviceModel), isInit,
+                result -> {
+                    if (result.isSuccess()) {
+                        QLog.i(TAG, "解绑设备成功");
+                        WritableMap writableMap = Arguments.createMap();
+                        promise.resolve(writableMap);
+                    } else {
+                        promise.reject(ErrorCode.ERROR_CODE_REQUEST_FAIL, result.getMsg());
+                        QLog.e(TAG, "解绑设备失败: " + result.getMsg());
+                    }
+                });
+    }
+
+    @ReactMethod
+    @Override
+    public void getTsl(String productKey, Promise promise) {
+        IDevService devService = DeviceServiceFactory.getInstance().getService(IDevService.class);
+        devService.queryProductTSLWithCache(QuecBaseApp.getInstance(), productKey, new IHttpCallBack() {
+            @Override
+            public void onSuccess(String result) {
+                try {
+                    JSONObject jsonObject = new JSONObject(result);
+                    int code = jsonObject.optInt("code");
+                    String msg = jsonObject.optString("msg");
+                    if (code != 200) {
+                        QLog.e("获取物模型失败-json解析异常");
+                        promise.reject(ErrorCode.ERROR_CODE_JSON_EXCEPTION, msg);
+                        return;
+                    }
+
+                    WritableMap writableMap = Arguments.createMap();
+                    JSONObject obj = jsonObject.optJSONObject("data");
+                    if (obj == null || obj.length() == 0) {
+                        writableMap.putArray("data", Arguments.createArray());
+                        QLog.e("获取物模型成功--空数据 data");
+                        promise.resolve(writableMap);
+                        return;
+                    }
+
+                    CacheTSLModel.saveModelsToMap(productKey);
+                    JSONArray jsonArrayProperties = obj.optJSONArray("properties");
+                    List<ModelBasic> list = ObjectModelParse.buildModelListContent(jsonArrayProperties);
+
+                    try {
+                        JSONArray jsonArray = new JSONArray(QuecGsonUtil.INSTANCE.gsonString(list));
+                        WritableArray writableArray = ReactNativeJson.convertJsonToArray(jsonArray);
+                        writableMap.putArray("data", writableArray);
+                        QLog.e("获取物模型成功--空数据 data: " + writableMap);
+                        promise.resolve(writableMap);
+                    } catch (JSONException e) {
+                        QLog.e("获取物模型失败-json解析异常");
+                        promise.reject(ErrorCode.ERROR_CODE_JSON_EXCEPTION, e.getLocalizedMessage());
+                        QLog.e(TAG, e);
+                    }
+
+
+                } catch (Exception e) {
+                    QLog.e("获取物模型失败-json解析异常");
+                    promise.reject(ErrorCode.ERROR_CODE_JSON_EXCEPTION, e.getLocalizedMessage());
+                    QLog.e(TAG, e);
+                }
+
+            }
+
+            @Override
+            public void onFail(Throwable e) {
+                QLog.e("获取物模型失败-接口异常");
+                promise.reject(ErrorCode.ERROR_CODE_JSON_EXCEPTION, e.getLocalizedMessage());
+                QLog.e(TAG, e);
+            }
+        });
+    }
+
+    @ReactMethod
+    @Override
+    public void startVerifyDevice(String productKey, String deviceKey, Promise promise) {
+        Activity activity = getCurrentActivity();
+        if (activity != null) {
+            SmartConfigServiceManager.getInstance().verifySingleDeviceStart(activity, productKey, deviceKey, result -> {
+                if (result.isSuccess()) {
+                    promise.resolve(0);
+                } else {
+                    promise.reject(result.getCode() + "", result.getMsg());
+                }
+            });
+        } else {
+            QLog.i(TAG, "startVerifyDevice fail, activity is null");
+        }
+    }
+
+    @ReactMethod
+    @Override
+    public void startNetConfigDevice(String productKey, String deviceKey, Promise promise) {
+        Activity activity = getCurrentActivity();
+        if (activity != null) {
+            SmartConfigServiceManager.getInstance().netConfigSingleDeviceStart(activity, productKey, deviceKey,
+                    result -> {
+                        if (result.isSuccess()) {
+                            promise.resolve(0);
+                        } else {
+                            promise.reject(result.getCode() + "", result.getMsg());
+                        }
+                    });
+        } else {
+            QLog.i(TAG, "startVerifyDevice fail, activity is null");
+        }
+    }
+
+    @ReactMethod
+    @Override
+    public void getSharePermList(ReadableArray shareCodeList, Promise promise) {
+        ArrayList<String> list = new ArrayList<>();
+        for (int i = 0; i < shareCodeList.size(); i++) {
+            list.add(shareCodeList.getString(i));
+        }
+        QuecDeviceShareService.INSTANCE.getSharePermList(list, getCallback(promise));
+    }
+
+    @ReactMethod
+    @Override
+    public void uploadDeviceHistoricalData(String productKey, String deviceKey, Promise promise) {
+        QuecDeviceDataUploadManager.INSTANCE.uploadDeviceHistoricalData(productKey, deviceKey, getSimpleCallback(promise));
+    }
+
+    @ReactMethod
+    @Override
+    public void getVoiceSupport(String productKey, String uid, String account, Promise promise) {
+        final boolean isSupportAlexa = QuecOemAppConfig.INSTANCE.getBusiness().isSupportAlexa();
+        final boolean isSupportGoogleAssistant = QuecOemAppConfig.INSTANCE.getBusiness().isSupportGoogleAssistant();
+        if (!isSupportAlexa && !isSupportGoogleAssistant) {
+            WritableMap map = Arguments.createMap();
+            map.putBoolean("supportAlexa", false);
+            map.putBoolean("supportAssistant", false);
+            promise.resolve(map);
+            return;
+        }
+        QuecDeviceService.INSTANCE.getVoiceSupport(productKey, uid, account, new QuecCallback<QuecVoiceSupport>() {
+            @Override
+            public void onResult(@NonNull QuecResult<QuecVoiceSupport> result) {
+                if (!result.isSuccess()) {
+                    promise.reject(String.valueOf(result.getCode()), result.getMsg());
+                    return;
+                }
+
+                QuecVoiceSupport data = result.getData();
+                final boolean productSupportAlexa = data != null && data.getProductSupportAlexa();
+                final boolean productSupportAssistant = data != null && data.getProductSupportAssistant();
+
+                WritableMap map = Arguments.createMap();
+                map.putBoolean("supportAlexa", productSupportAlexa && isSupportAlexa);
+                map.putBoolean("supportAssistant", productSupportAssistant && isSupportGoogleAssistant);
+                promise.resolve(map);
+            }
+        });
+    }
+
+    private QuecIotDataSendMode getDefaultDataSendMode() {
+        return QuecIotDataSendMode.QuecIotDataSendModeAuto;
+    }
+
+    private QuecIotDataSendMode getDataSendMode(int mode) {
+        QuecIotDataSendMode sendMode;
+        switch (mode) {
+            case 1:
+                sendMode = QuecIotDataSendMode.QuecIotDataSendModeWS;
+                break;
+            case 2:
+                sendMode = QuecIotDataSendMode.QuecIotDataSendModeWifi;
+                break;
+            case 3:
+                sendMode = QuecIotDataSendMode.QuecIotDataSendModeBLE;
+                break;
+            default:
+                sendMode = QuecIotDataSendMode.QuecIotDataSendModeAuto;
+                break;
+        }
+
+        return sendMode;
+    }
+
+    private void checkResult(QuecResult<?> result) {
+        if (result == null) {
+            return;
+        }
+        if (TextUtils.isEmpty(result.getMsg()) || result.getMsg().contains("Unable to resolve host")) {
+            result.setMsg(QuecBaseApp.getInstance().getString(com.quectel.ui.config.R.string.quec_error_code_default));
+        }
+    }
+
+    private Throwable checkError(Throwable throwable) {
+        if (TextUtils.isEmpty(throwable.getMessage()) || throwable.getMessage().contains("Unable to resolve host")) {
+            return new Error(QuecBaseApp.getInstance().getString(com.quectel.ui.config.R.string.quec_error_code_default));
+        }
+        return throwable;
+    }
+
+    private QuecSimpleCallBack getSimpleCallback(Promise promise) {
+        return result -> {
+            if (result.isSuccess()) {
+                promise.resolve(Arguments.createMap());
+            } else {
+                promise.reject(result.getCode() + "", result.getMsg());
+            }
+        };
+    }
+
+    private <T> QuecCallback<T> getCallback(Promise promise) {
+        return result -> ResponseUtils.handlerResponse(promise, result, viewModel);
+    }
+
+    private void checkDeviceList(List<QuecDeviceModel> list) {
+        QLog.i(TAG, "checkDeviceList");
+        if (deviceModel != null && list != null) {
+            for (QuecDeviceModel model : list) {
+                checkDevice(model);
+            }
+        }
+    }
+
+    private void checkDevice(QuecDeviceModel model) {
+        if (model == null) {
+            return;
+        }
+        QuecDeviceClientApi client = QuecDeviceClient.Companion.initWithId(model.getChannelId());
+        if (client != null) {
+            client.updateDeviceInfo(model);
+        }
+
+        if (deviceModel != null && deviceModel.getChannelId().equals(model.getChannelId())) {
+            QLog.i(TAG, "update current deviceModel");
+            deviceModel = model;
+            //更新当前设备的缓存
+            String deviceStr = QuecGsonUtil.INSTANCE.gsonString(model);
+            MmkvManager.getInstance().put(Constants.QUEC_DEVICE_MODEL, deviceStr);
+            QuecDevicePanelServiceManager.getInstance().setCurrentDeviceInfo(deviceStr);
+        }
+    }
+
+    private void waitInit(QuecSimpleCallBack callBack) {
+        if (latch.getCount() <= 0) {
+            QuecThreadUtil.RunMainThread(() -> callBack.onResult(new QuecResult<>(true, 0)));
+        } else {
+            //需等待
+            QuecThreadUtil.RunSubThread(() -> {
+                try {
+                    latch.await(); // 等待初始化完成
+                    QuecThreadUtil.RunMainThread(() -> callBack.onResult(new QuecResult<>(true, 0)));
+                } catch (Exception e) {
+                    QLog.e(TAG, "waitInit error: " + e);
+                }
+            });
+        }
+    }
+
+    private void dealWithVerified() {
+        QLog.i(TAG, "dealWithVerified");
+        deviceModel = deviceClient.getModel();
+
+        //更新设备持久化信息
+        String deviceInfoKey = "quecDeviceModel";
+        String json = MmkvManager.getInstance().get(deviceInfoKey, "");
+        if (!TextUtils.isEmpty(json)) {
+            try {
+                Gson gson = new Gson();
+                QuecDeviceModel quecDeviceModel = gson.fromJson(json, QuecDeviceModel.class);
+                if (channelId.equals(quecDeviceModel.getChannelId())) {
+                    QLog.i(TAG, "update quecDeviceModel");
+                    MmkvManager.getInstance().put(deviceInfoKey, gson.toJson(deviceClient.getModel()));
+                }
+            } catch (Exception e) {
+                QLog.e(TAG, e);
+            }
+        }
+    }
+}