mini_program_gizwits_sdk 3.6.1 → 3.6.2

package/dist/src/sdk.js

@@ -0,0 +1,1101 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const globalData_1 = require("./globalData");
+const package_json_1 = __importDefault(require("../package.json"));
+const lan_1 = require("./handler/lan");
+const productConfigFileManage_1 = __importDefault(require("./productConfigFileManage"));
+const dataPoint_1 = require("./protocol/dataPoint");
+const Ntp_1 = __importDefault(require("./protocol/Ntp"));
+const OffLineData_1 = require("./protocol/OffLineData");
+const ProtocolBase_1 = __importDefault(require("./protocol/ProtocolBase"));
+const tool_1 = require("./protocol/tool");
+const ble_1 = require("./handler/ble");
+const socket_1 = __importDefault(require("./handler/socket"));
+const Reset_1 = __importDefault(require("./protocol/Reset"));
+const SetReset_1 = __importDefault(require("./protocol/SetReset"));
+const GizLog_1 = __importDefault(require("./GizLog"));
+const errorCode_1 = __importDefault(require("./errorCode"));
+const devices_1 = require("./services/devices");
+const login_1 = require("./services/login");
+const uploadP0_1 = require("./services/uploadP0");
+const sleep_1 = __importDefault(require("./sleep"));
+const utils_1 = require("./utils");
+const ap_1 = __importDefault(require("./wifiConfig/ap"));
+const ble_2 = __importDefault(require("./wifiConfig/ble"));
+const nfc_1 = __importDefault(require("./wifiConfig/nfc"));
+const version = package_json_1.default.version;
+class GizwitsMiniSDK {
+    get deviceList() {
+        return this._deviceList;
+    }
+    set deviceList(data) {
+        this._deviceList = data;
+        this.notiDeviceList();
+    }
+    get bleDevices() {
+        return this._bleDevices;
+    }
+    set bleDevices(data) {
+        this._bleDevices = data;
+        this.notiDeviceList();
+    }
+    get lanDevices() {
+        return this._lanDevices;
+    }
+    set lanDevices(data) {
+        this._lanDevices = data;
+        this.notiDeviceList();
+    }
+    get allDevices() {
+        let newDevices = (0, utils_1.merageBleLocalDevices)([...this.deviceList], this.bleDevices);
+        newDevices = (0, utils_1.merageLanLocalDevices)(newDevices, this.lanDevices);
+        this.bleHandle.connectedList.map((item) => {
+            const index = newDevices.findIndex((device) => device.bleDeviceID === item.deviceId);
+            if (index !== -1) {
+                newDevices[index].connectType = 'BLE';
+            }
+        });
+        const connectionMap = this.socketHandle._connections;
+        Object.keys(connectionMap).forEach((wsInfo) => {
+            const conn = connectionMap[wsInfo];
+            if (conn) {
+                conn._subDids.forEach((did) => {
+                    const index = newDevices.findIndex((device) => device.did === did);
+                    if (index !== -1) {
+                        newDevices[index].connectType = 'WAN';
+                    }
+                });
+            }
+        });
+        const lanConnected = this.lanHandle.connectedList;
+        lanConnected.map(item => {
+            const index = newDevices.findIndex((device) => device.mac === item.mac && device.productKey === item.productKey);
+            if (index !== -1) {
+                newDevices[index].connectType = 'LAN';
+            }
+        });
+        return newDevices;
+    }
+    get bleScanDevice() {
+        return this.bleDevices.filter((item) => item.isBleOnline === true);
+    }
+    constructor(props) {
+        this.listenerMap = {};
+        this.keepScanTimer = null;
+        this._deviceList = [];
+        this._bleDevices = [];
+        this._lanDevices = [];
+        this.productInfo = [];
+        this.syncDataCallBack = null;
+        this.syncTotalNum = 0;
+        this.syncCurrnetNum = 0;
+        this.syncDataTimoutTimer = null;
+        this.SYNC_TIMEOUT = 4 * 60 * 1000;
+        this.init = ({ appID, appSecret, productInfo, cloudServiceInfo, token, uid, offlineThreshold, }) => {
+            this.productInfo = productInfo;
+            (0, globalData_1.setGlobalData)('appID', appID);
+            (0, globalData_1.setGlobalData)('appSecret', appSecret);
+            (0, globalData_1.setGlobalData)('productInfo', productInfo);
+            (0, globalData_1.setGlobalData)('token', token);
+            (0, globalData_1.setGlobalData)('uid', uid);
+            this.setDomain(cloudServiceInfo);
+            this.offlineThreshold = offlineThreshold;
+            GizLog_1.default.debug(`init sdk success, current version: ${GizwitsMiniSDK.getVersion().data}`);
+            this.initLan();
+        };
+        this.handleBleError = (e) => {
+            if (this.listenerMap['onBleHandleError']) {
+                this.listenerMap['onBleHandleError'].map((item) => {
+                    item(e);
+                });
+            }
+        };
+        this.handleBleDevices = (devices) => {
+            this.bleDevices = devices;
+        };
+        this.handleLanDevices = (devices) => {
+            this.lanDevices = devices;
+        };
+        this.handleLanDeviceData = (mac, hexString) => __awaiter(this, void 0, void 0, function* () {
+            const target = this.allDevices.find((item) => item.mac === mac);
+            if (target) {
+                const data = yield (0, dataPoint_1.unpack)((0, tool_1.hexStrint2byte)(hexString), target.productKey);
+                if ((data === null || data === void 0 ? void 0 : data.kvData) && this.listenerMap['GizDeviceAttrsNotifications']) {
+                    this.listenerMap['GizDeviceAttrsNotifications'].map((item) => {
+                        item({
+                            device: target,
+                            data: data === null || data === void 0 ? void 0 : data.kvData,
+                        });
+                    });
+                }
+            }
+        });
+        this.handleBleDeviceData = (curDevice, hexString) => __awaiter(this, void 0, void 0, function* () {
+            const target = this.allDevices.find((item) => item.bleDeviceID === curDevice.deviceId);
+            if (target) {
+                const bleBytesData = (0, tool_1.hexStrint2byte)(hexString);
+                const parseData = new ProtocolBase_1.default(bleBytesData);
+                switch (parseData.cmd) {
+                    case '0093':
+                    case '0094':
+                    case '0090':
+                    case '0091': {
+                        console.debug('handleBleDeviceData', hexString, target);
+                        if (target.passcode) {
+                            const productConfig = this.productInfo.find(item => item.productKey === target.productKey);
+                            if (productConfig) {
+                                const uploadTime = parseInt(`${Date.now() / 1000}`, 10);
+                                (0, uploadP0_1.uploadP0)({
+                                    device: target,
+                                    data: [
+                                        {
+                                            raw: hexString,
+                                            created_at: uploadTime
+                                        }
+                                    ],
+                                    productSecret: productConfig.productSecret,
+                                }).then(data => {
+                                    GizLog_1.default.debug("设备上报数据:timestemp", new Date(uploadTime * 1000).toLocaleString(), data);
+                                });
+                            }
+                        }
+                        const data = yield (0, dataPoint_1.unpack)((0, tool_1.hexStrint2byte)(hexString), target.productKey);
+                        if ((data === null || data === void 0 ? void 0 : data.kvData) && this.listenerMap['GizDeviceAttrsNotifications']) {
+                            this.listenerMap['GizDeviceAttrsNotifications'].map((item) => {
+                                item({
+                                    device: target,
+                                    data: data === null || data === void 0 ? void 0 : data.kvData,
+                                });
+                            });
+                        }
+                        break;
+                    }
+                    case '0062': {
+                        const resetInfo = new Reset_1.default(bleBytesData);
+                        GizLog_1.default.debug("收到代理重置事件", resetInfo);
+                        if (resetInfo.status === 1) {
+                            this.deviceSafetyApi({
+                                mac: target.mac,
+                                productKey: target.productKey,
+                                isReset: true
+                            }).then((data) => __awaiter(this, void 0, void 0, function* () {
+                                GizLog_1.default.debug("代理重置结果", data);
+                                if (data.success && data.data.successDevices.length > 0) {
+                                    GizLog_1.default.debug("重置成功，回写数据");
+                                    yield this.bleHandle.write(curDevice.deviceId, (0, utils_1.numberArray2Uint8Array)(SetReset_1.default.pack(0)).buffer);
+                                }
+                            }));
+                        }
+                        break;
+                    }
+                    case '0064': {
+                        break;
+                    }
+                    case '0072': {
+                        const requestSyncData = new OffLineData_1.RequestSync(bleBytesData);
+                        GizLog_1.default.debug("设备回复是否允许同步， state:", requestSyncData.state);
+                        this.syncDataLengthCallback && this.syncDataLengthCallback({ success: requestSyncData.state == 0, data: requestSyncData.len });
+                        if (!this.syncDataCallBack)
+                            break;
+                        if (requestSyncData.state === 0) {
+                            this.syncCurrnetNum = 0;
+                            this.syncTotalNum = requestSyncData.len;
+                            this.syncDataCallBack({
+                                event: 'SYNC_START',
+                                totalNum: this.syncTotalNum,
+                                currentNum: this.syncCurrnetNum
+                            });
+                            GizLog_1.default.debug("查询第一条离线数据");
+                            yield this.bleHandle.write(curDevice.deviceId, (0, utils_1.numberArray2Uint8Array)(OffLineData_1.SyncPackage.pack(0)).buffer);
+                        }
+                        else {
+                            GizLog_1.default.debug("设备返回状态为1，同步失败");
+                            this.syncDataCallBack({
+                                event: 'SYNC_FAIL',
+                            });
+                        }
+                        break;
+                    }
+                    case '0074': {
+                        if (!this.syncDataCallBack)
+                            break;
+                        GizLog_1.default.debug("设备上报离线数据");
+                        const syncPackageData = new OffLineData_1.SyncPackage(bleBytesData);
+                        const deletePackageCmd = OffLineData_1.DeletePackage.pack(syncPackageData.id);
+                        GizLog_1.default.debug("设备上报离线数据:payload", syncPackageData.payload);
+                        try {
+                            GizLog_1.default.debug("设备上报离线数据:timestemp", new Date(syncPackageData.timestemp * 1000).toLocaleString());
+                        }
+                        catch (error) {
+                        }
+                        const productConfig = this.productInfo.find(item => item.productKey === this.syncDevice.productKey);
+                        if (productConfig) {
+                            const uploadRes = yield (0, uploadP0_1.uploadP0)({
+                                device: this.syncDevice,
+                                data: [
+                                    {
+                                        raw: (0, tool_1.arrayToString)(syncPackageData.payload),
+                                        created_at: syncPackageData.timestemp
+                                    }
+                                ],
+                                productSecret: productConfig.productSecret
+                            });
+                            GizLog_1.default.debug("上传离线数据结果", uploadRes);
+                        }
+                        this.syncCurrnetNum += 1;
+                        this.syncDataCallBack({
+                            event: "SYNC_PROGRESS",
+                            totalNum: this.syncTotalNum,
+                            currentNum: this.syncCurrnetNum
+                        });
+                        GizLog_1.default.debug("通知设备删除：", syncPackageData.id);
+                        yield this.bleHandle.write(curDevice.deviceId, (0, utils_1.numberArray2Uint8Array)(deletePackageCmd).buffer);
+                        yield (0, sleep_1.default)(100);
+                        if (syncPackageData.id < this.syncTotalNum - 1) {
+                            GizLog_1.default.debug("查询新数据：", syncPackageData.id + 1);
+                            yield this.bleHandle.write(curDevice.deviceId, (0, utils_1.numberArray2Uint8Array)(OffLineData_1.SyncPackage.pack(syncPackageData.id + 1)).buffer);
+                        }
+                        else {
+                            GizLog_1.default.debug("send cancel sync to device");
+                            this.bleHandle.write(curDevice.deviceId, (0, utils_1.numberArray2Uint8Array)(OffLineData_1.CancelSync.pack()).buffer);
+                            this.syncDataCallBack({
+                                event: "SYNC_END",
+                            });
+                            this.cleanSyncDeviceData();
+                        }
+                        break;
+                    }
+                    case '0078': {
+                        if (!this.syncDataCallBack)
+                            break;
+                        const cancelData = new OffLineData_1.CancelSync(bleBytesData);
+                        GizLog_1.default.debug("设备上报停止同步 state:", cancelData.state);
+                        if (cancelData.state === 0) {
+                            this.syncDataCallBack({
+                                event: "SYNC_END",
+                            });
+                        }
+                        else {
+                            this.syncDataCallBack({
+                                event: "SYNC_FAIL",
+                            });
+                        }
+                        this.cleanSyncDeviceData();
+                        break;
+                    }
+                    case '0060': {
+                        break;
+                    }
+                }
+            }
+        });
+        this.handleSocketDeviceData = (data) => __awaiter(this, void 0, void 0, function* () {
+            const target = this.allDevices.find((item) => item.did === data.did);
+            if (!target) {
+                return;
+            }
+            if (data.attrs && data.attrs.is_online != null) {
+                const isOnline = data.attrs.is_online;
+                this.setDeviceMeta(target, 'isOnline', isOnline);
+            }
+            if (this.listenerMap['GizDeviceAttrsNotifications']) {
+                if (data.attrs) {
+                    data.attrs = yield (0, dataPoint_1.formatEnum)(data.attrs, target.productKey, 'int');
+                }
+                this.listenerMap['GizDeviceAttrsNotifications'].map((item) => {
+                    item(Object.assign({ device: target }, ('attrs' in data ? { data: data.attrs } : { raw: data.raw })));
+                });
+            }
+        });
+        this.handleSocketStatus = (dids, enabled) => {
+            const devices = this.allDevices.filter((item) => dids.includes(item.did) && item.connectType === 'WAN');
+            GizLog_1.default.log('handleSocketStatus', dids, enabled);
+            devices.forEach((item) => {
+                this.setDeviceMeta(item, 'connectType', enabled ? 'WAN' : 'NONE');
+            });
+        };
+        this.notiDeviceList = () => {
+            var _a, _b;
+            (_a = this.listenerMap['GizDeviceListNotifications']) === null || _a === void 0 ? void 0 : _a.map((notifyFn) => {
+                notifyFn(this.allDevices);
+            });
+            (_b = this.listenerMap['onScanListChange']) === null || _b === void 0 ? void 0 : _b.map((notifyFn) => {
+                notifyFn(this.bleScanDevice);
+            });
+        };
+        this.initLan = () => {
+            try {
+                this.lanHandle.init();
+                this.lanHandle.addEventListener('GizLanDeviceList', this.handleLanDevices);
+                this.lanHandle.addEventListener('GizLanDeviceData', this.handleLanDeviceData);
+            }
+            catch (error) {
+                GizLog_1.default.error('init lan error', error);
+            }
+        };
+        this.startAutoScan = (services) => {
+            const autoTime = 9000;
+            if (this.keepScanTimer) {
+                return;
+            }
+            this.keepScanTimer = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+                this.bleHandle.startScan(-1, services);
+            }), autoTime);
+            this.bleHandle.startScan(-1, services);
+        };
+        this.stopAutoScan = () => {
+            this.keepScanTimer && clearInterval(this.keepScanTimer);
+            this.bleHandle.stopScan();
+        };
+        this.setDeviceMeta = (curDev, key, value, force = false) => {
+            const target = this.allDevices.find((dev) => dev.mac === curDev.mac);
+            if (!target || this.allDevices.length === 0) {
+                return;
+            }
+            if (curDev[key] !== value || force) {
+                target[key] = value;
+                this.notiDeviceList();
+            }
+        };
+        this.setDevicesMeta = (devices, key, value, force = false) => {
+            let hasChange = false;
+            const targets = devices.map((dev) => this.allDevices.find((item) => item.mac === dev.mac));
+            for (let i = 0; i < targets.length; i++) {
+                const target = targets[i];
+                if (target) {
+                    if (target[key] !== value || force) {
+                        target[key] = value;
+                        hasChange = true;
+                    }
+                }
+            }
+            hasChange && this.notiDeviceList();
+        };
+        this.initBle = () => __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.bleHandle.addEventListener('GizBleDeviceData', this.handleBleDeviceData);
+                this.bleHandle.addEventListener('GizBleDeviceList', this.handleBleDevices);
+                this.bleHandle.addEventListener('GizBleError', this.handleBleError);
+                const permissionData = yield this.bleHandle.checkPermission();
+                if (!permissionData.success) {
+                    GizLog_1.default.error('init BLE Error', new Error(JSON.stringify(permissionData)));
+                    return {
+                        success: false,
+                        err: errorCode_1.default.GIZ_SDK_BLE_BLUETOOTH_FUNCTION_NOT_TURNED_ON,
+                    };
+                }
+                GizLog_1.default.debug('init BLE succcess', permissionData);
+            }
+            catch (error) {
+                GizLog_1.default.error('init BLE error', error);
+                return { success: false, err: errorCode_1.default.GIZ_SDK_BLE_BLUETOOTH_FUNCTION_NOT_TURNED_ON };
+            }
+            return { success: true };
+        });
+        this.scanBleDevice = (delay, services) => __awaiter(this, void 0, void 0, function* () {
+            this.bleHandle.scanList = [];
+            const data = yield this.bleHandle.startScan(delay, services);
+            return {
+                success: true,
+                data: data.scanList,
+            };
+        });
+        this.write = (device, attrs) => __awaiter(this, void 0, void 0, function* () {
+            const target = this.allDevices.find((item) => (0, utils_1.isSameDevice)(item, device));
+            if (!target) {
+                return { success: false, message: 'target is undefind' };
+            }
+            if (target.connectType !== 'NONE') {
+                const { data: value, raw } = yield (0, dataPoint_1.pack)(attrs, target.productKey);
+                switch (target.connectType) {
+                    case 'BLE_BROADCAST':
+                        return yield this.bleHandle.writeBoradcast(target.bleDeviceID, raw.cmd);
+                    case 'BLE': {
+                        if (value) {
+                            return yield this.bleHandle.write(target.bleDeviceID, (0, utils_1.numberArray2Uint8Array)(value).buffer);
+                        }
+                        else {
+                            return {
+                                success: false,
+                            };
+                        }
+                    }
+                    case 'WAN': {
+                        const newAttrs = yield (0, dataPoint_1.formatEnum)(attrs, target.productKey, 'string');
+                        return this.socketHandle.writeData(target, newAttrs);
+                    }
+                    case 'LAN': {
+                        return this.lanHandle.write(target, (0, utils_1.numberArray2Uint8Array)(value).buffer);
+                    }
+                }
+            }
+            return {
+                success: false,
+            };
+        });
+        this.writeRaw = (device, data) => __awaiter(this, void 0, void 0, function* () {
+            const target = this.allDevices.find((item) => (0, utils_1.isSameDevice)(item, device));
+            if (!target) {
+                return { success: false, message: 'target is undefind' };
+            }
+            if (target.connectType !== 'NONE') {
+                switch (target.connectType) {
+                    case 'BLE_BROADCAST':
+                        return yield this.bleHandle.writeBoradcast(target.bleDeviceID, data);
+                    case 'BLE': {
+                        if (data) {
+                            return yield this.bleHandle.write(target.bleDeviceID, (0, utils_1.numberArray2Uint8Array)(data).buffer);
+                        }
+                        else {
+                            return {
+                                success: false,
+                            };
+                        }
+                    }
+                    case 'WAN': {
+                        return this.socketHandle.send(target.did, data);
+                    }
+                    case 'LAN': {
+                        return this.lanHandle.write(target, (0, utils_1.numberArray2Uint8Array)(data).buffer);
+                    }
+                }
+            }
+            return {
+                success: false,
+            };
+        });
+        this.setDeviceTimeStamp = (device) => __awaiter(this, void 0, void 0, function* () {
+            const target = this.allDevices.find((item) => (0, utils_1.isSameDevice)(item, device));
+            if (!target) {
+                return { success: false, message: 'target is undefind' };
+            }
+            const data = Ntp_1.default.pack();
+            switch (target.connectType) {
+                case 'BLE': {
+                    return this.bleHandle.write(device.bleDeviceID, (0, utils_1.numberArray2Uint8Array)(data).buffer);
+                }
+            }
+            return {
+                success: false,
+                message: 'the connectType not support set timestamp'
+            };
+        });
+        this.syncDeviceData = (device, callback = () => { }) => __awaiter(this, void 0, void 0, function* () {
+            const target = this.allDevices.find((item) => (0, utils_1.isSameDevice)(item, device));
+            if (!target) {
+                return { success: false, message: 'target is undefind' };
+            }
+            if (!target.isBind) {
+                return { success: false, message: 'Only the bound devices are supported' };
+            }
+            if (this.syncDevice) {
+                return {
+                    success: false,
+                    message: 'Synchronizing'
+                };
+            }
+            this.syncDevice = Object.assign({}, target);
+            switch (target.connectType) {
+                case 'BLE': {
+                    GizLog_1.default.debug("start syncDeviceData", device);
+                    this.syncDataCallBack = callback;
+                    this.syncDataTimoutTimer = setTimeout(() => {
+                        this.syncDataCallBack({
+                            event: 'SYNC_FAIL',
+                            message: 'sync timeout'
+                        });
+                        this.cleanSyncDeviceData();
+                    }, this.SYNC_TIMEOUT);
+                    const data = OffLineData_1.RequestSync.pack();
+                    GizLog_1.default.debug("sent RequestSync data");
+                    return this.bleHandle.write(device.bleDeviceID, (0, utils_1.numberArray2Uint8Array)(data).buffer);
+                }
+            }
+            return {
+                success: false,
+                message: 'the connectType not support sync data'
+            };
+        });
+        this.queryNeedSyncDataLength = (device) => __awaiter(this, void 0, void 0, function* () {
+            const target = this.allDevices.find((item) => (0, utils_1.isSameDevice)(item, device));
+            if (!target) {
+                return { success: false, message: 'target is undefind' };
+            }
+            if (!target.isBind) {
+                return { success: false, message: 'Only the bound devices are supported' };
+            }
+            switch (target.connectType) {
+                case 'BLE': {
+                    const data = OffLineData_1.RequestSync.pack();
+                    this.syncDevice = Object.assign({}, target);
+                    GizLog_1.default.debug("sent RequestSync data len");
+                    this.bleHandle.write(device.bleDeviceID, (0, utils_1.numberArray2Uint8Array)(data).buffer);
+                    return new Promise((res) => {
+                        this.syncDataLengthCallback = res;
+                        setTimeout(() => {
+                            try {
+                                res({ success: false, message: 'timeout' });
+                            }
+                            catch (error) {
+                            }
+                        }, 3000);
+                    });
+                }
+            }
+            return {
+                success: false,
+                message: 'the connectType not support sync data'
+            };
+        });
+        this.cancelSyncDeviceData = () => __awaiter(this, void 0, void 0, function* () {
+            this.cleanSyncDeviceData();
+        });
+        this.cleanSyncDeviceData = () => {
+            if (this.syncDataCallBack) {
+                this.syncDataCallBack({
+                    event: 'SYNC_CANCEL'
+                });
+                this.syncDataCallBack = null;
+            }
+            this.syncCurrnetNum = 0;
+            this.syncTotalNum = 0;
+            this.syncDevice = null;
+            this.syncDataTimoutTimer && clearTimeout(this.syncDataTimoutTimer);
+        };
+        this.getProductConfig = (pk) => __awaiter(this, void 0, void 0, function* () {
+            const data = yield productConfigFileManage_1.default.getConfigFile(pk);
+            if (data) {
+                return {
+                    success: true,
+                    data,
+                };
+            }
+            return {
+                success: false,
+            };
+        });
+        this.stopScanBleDevice = () => {
+            this.bleHandle.stopScan();
+        };
+        this.login = (openID) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const data = yield (0, login_1.AnonymousLogin)({ uid: openID });
+            if (data.success) {
+                (0, globalData_1.setGlobalData)('token', (_a = data.data) === null || _a === void 0 ? void 0 : _a.token);
+                (0, globalData_1.setGlobalData)('uid', (_b = data.data) === null || _b === void 0 ? void 0 : _b.uid);
+                this.socketHandle.updateToken({ token: data.data.token, uid: data.data.uid });
+            }
+            return data;
+        });
+        this.getDeviceStatus = (device, attrNames) => __awaiter(this, void 0, void 0, function* () {
+            const target = this.allDevices.find((item) => (0, utils_1.isSameDevice)(item, device));
+            if (!target) {
+                return { success: false, message: 'target is undefind' };
+            }
+            switch (target.connectType) {
+                case 'BLE': {
+                    return yield this.bleHandle.getDeviceStatus(target.bleDeviceID, target.productKey, target.rootDeviceId, attrNames);
+                }
+                case 'WAN':
+                    return this.socketHandle.readStatus(target, attrNames);
+                default: {
+                    return {
+                        success: false,
+                        message: 'Device connectType is unsupported',
+                    };
+                }
+            }
+        });
+        this.subscribe = (device, connectType, _autoGetDeviceStatus = true) => __awaiter(this, void 0, void 0, function* () {
+            GizLog_1.default.debug("subscribe device:", device);
+            let target = this.allDevices.find((item) => (0, utils_1.isSameDevice)(item, device));
+            if (!target) {
+                GizLog_1.default.warn('Device Target Not Found');
+                GizLog_1.default.warn('current devices ', this.allDevices);
+                return { success: false, message: "device not found" };
+            }
+            if (target.connectType === 'BLE_BROADCAST') {
+                return {
+                    success: true,
+                    message: '',
+                };
+            }
+            const type = (0, utils_1.getFirstConnectType)(target, connectType);
+            if (target.connectType !== 'NONE' && target.connectType !== type) {
+                yield this.unSubscribe(target);
+            }
+            switch (type) {
+                case 'BLE': {
+                    const data = yield this.bleHandle.connectDevice(target);
+                    if (data.success) {
+                        this.setDeviceMeta(target, 'connectType', 'BLE', true);
+                        setTimeout(() => {
+                            this.setDeviceTimeStamp(target);
+                        }, 250);
+                        setTimeout(() => {
+                            this.getDeviceStatus(target);
+                        }, 500);
+                    }
+                    return data;
+                }
+                case 'WAN': {
+                    const data = this.socketHandle.connectDevice(target);
+                    if (data.success) {
+                        this.setDeviceMeta(device, 'connectType', 'WAN', true);
+                    }
+                    return data;
+                }
+                case 'LAN': {
+                    const data = yield this.lanHandle.connectDevice(target);
+                    if (data.success) {
+                        this.setDeviceMeta(device, 'connectType', 'LAN', true);
+                    }
+                    return data;
+                }
+            }
+            return {
+                success: false,
+                message: '',
+            };
+        });
+        this.batchSubscribe = (devices, connectType) => __awaiter(this, void 0, void 0, function* () {
+            var _c, _d, _e;
+            GizLog_1.default.debug("subscribe devices =>", devices);
+            const sdkDevicesMap = this.allDevices.reduce((acc, cur) => (Object.assign(Object.assign({}, acc), { [(0, utils_1.getDeviceId)(cur)]: cur })), {});
+            const foundDevices = devices.filter((device) => sdkDevicesMap[(0, utils_1.getDeviceId)(device)]);
+            if (foundDevices.length === 0) {
+                GizLog_1.default.warn('Device Target Not Found');
+                GizLog_1.default.warn('current devices ', this.allDevices);
+                return { success: false, message: "device not found" };
+            }
+            const connectTypeMap = foundDevices.reduce((acc, cur) => {
+                const type = cur.connectType === 'BLE_BROADCAST' ? 'BLE_BROADCAST' : (0, utils_1.getFirstConnectType)(cur, connectType);
+                if (!acc[type]) {
+                    acc[type] = [];
+                }
+                acc[type].push(cur);
+                return acc;
+            }, {});
+            const types = Object.keys(connectTypeMap);
+            if (types.length === 1 && types[0] === 'BLE_BROADCAST') {
+                return {
+                    success: true,
+                    message: '',
+                };
+            }
+            if (((_c = connectTypeMap['BLE']) !== null && _c !== void 0 ? _c : []).length > 0 || ((_d = connectTypeMap['LAN']) !== null && _d !== void 0 ? _d : []).length > 0) {
+                return {
+                    success: false,
+                    message: 'BLE and LAN can not subscribe together'
+                };
+            }
+            const wanDevices = (_e = connectTypeMap['WAN']) !== null && _e !== void 0 ? _e : [];
+            if (wanDevices.length === 0) {
+                return {
+                    success: false,
+                    message: 'no WAN device'
+                };
+            }
+            const wanUnsubscribeDevices = wanDevices.filter((device) => {
+                return device.connectType !== 'NONE' && device.connectType !== 'WAN';
+            });
+            if (wanUnsubscribeDevices.length > 0) {
+                yield this.batchWanUnSubscribe(wanUnsubscribeDevices);
+            }
+            const data = this.socketHandle.connectDevices(wanDevices);
+            if (data.success) {
+                this.setDevicesMeta(wanDevices, 'connectType', 'WAN', true);
+            }
+            return data;
+        });
+        this.batchWanUnSubscribe = (devices) => __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.socketHandle.disConnectDevices(devices);
+            if (res.success) {
+                this.setDevicesMeta(devices, 'connectType', 'NONE', true);
+            }
+            return res;
+        });
+        this.unSubscribe = (device) => __awaiter(this, void 0, void 0, function* () {
+            const target = this.allDevices.find((item) => (0, utils_1.isSameDevice)(item, device));
+            switch (target.connectType) {
+                case 'BLE': {
+                    const disconnectRes = yield this.bleHandle.disConnectDevice(target.bleDeviceID);
+                    if (disconnectRes.success) {
+                        this.setDeviceMeta(target, 'connectType', 'NONE', true);
+                    }
+                    return disconnectRes;
+                }
+                case 'WAN': {
+                    const res = this.socketHandle.disConnectDevice(target);
+                    if (res.success) {
+                        this.setDeviceMeta(target, 'connectType', 'NONE', true);
+                    }
+                    return res;
+                }
+                case 'LAN': {
+                    const res = this.lanHandle.disConnectDevice(target);
+                    if (res.success) {
+                        this.setDeviceMeta(target, 'connectType', 'NONE', true);
+                    }
+                    return res;
+                }
+            }
+            return {
+                success: false,
+            };
+        });
+        this.bindRemoteDevice = ({ mac, productKey, alias, beOwner, }) => __awaiter(this, void 0, void 0, function* () {
+            const target = (0, utils_1.getProductInfoThroughPK)(productKey, this.productInfo);
+            if (target) {
+                const data = yield (0, devices_1.bindMac)({
+                    mac,
+                    productKey,
+                    productSecret: target.productSecret,
+                    alias,
+                    beOwner,
+                });
+                this.getBindingList();
+                return data;
+            }
+            return {
+                success: false,
+                err: errorCode_1.default.GIZ_SDK_PRODUCTKEY_NOT_IN_SPECIFY,
+            };
+        });
+        this.checkUpdate = ({ device, type }) => __awaiter(this, void 0, void 0, function* () {
+            const target = this.allDevices.find((item) => (0, utils_1.isSameDevice)(item, device));
+            if (target) {
+                if (!target.did) {
+                    return {
+                        success: false,
+                        err: errorCode_1.default.GIZ_OPENAPI_DEVICE_NOT_BOUND,
+                    };
+                }
+                switch (target.connectType) {
+                    case 'BLE': {
+                        return this.bleHandle.checkUpdate({ device, type });
+                    }
+                    default: {
+                        return {
+                            success: false,
+                            err: errorCode_1.default.GIZ_SDK_OTA_DEVICE_NOT_SUPPORT,
+                        };
+                    }
+                }
+            }
+            return {
+                success: false,
+                err: errorCode_1.default.GIZ_SDK_DEVICE_NOT_SUBSCRIBED,
+            };
+        });
+        this.getDeviceInfo = ({ device }) => __awaiter(this, void 0, void 0, function* () {
+            const target = this.allDevices.find((item) => (0, utils_1.isSameDevice)(item, device));
+            if (target) {
+                if (!target.did) {
+                    return {
+                        success: false,
+                        err: errorCode_1.default.GIZ_OPENAPI_DEVICE_NOT_BOUND,
+                    };
+                }
+                switch (target.connectType) {
+                    case 'BLE': {
+                        return this.bleHandle.getDeviceInfo({ deviceId: device.bleDeviceID });
+                    }
+                    default: {
+                        return {
+                            success: false,
+                            err: errorCode_1.default.GIZ_SDK_OTA_DEVICE_NOT_SUPPORT,
+                        };
+                    }
+                }
+            }
+            return {
+                success: false,
+                err: errorCode_1.default.GIZ_SDK_DEVICE_NOT_SUBSCRIBED,
+            };
+        });
+        this.startUpgrade = ({ device, type, onProgress, onEvent }) => __awaiter(this, void 0, void 0, function* () {
+            const target = this.allDevices.find((item) => (0, utils_1.isSameDevice)(item, device));
+            if (target) {
+                if (!target.did) {
+                    return {
+                        success: false,
+                        err: errorCode_1.default.GIZ_OPENAPI_DEVICE_NOT_BOUND,
+                    };
+                }
+                switch (target.connectType) {
+                    case 'BLE': {
+                        return this.bleHandle.startUpgrade({ device, type, productKey: device.productKey, onProgress, onEvent });
+                    }
+                    default: {
+                        return {
+                            success: false,
+                            err: errorCode_1.default.GIZ_SDK_OTA_DEVICE_NOT_SUPPORT,
+                        };
+                    }
+                }
+            }
+            return {
+                success: false,
+                err: errorCode_1.default.GIZ_SDK_DEVICE_NOT_SUBSCRIBED,
+            };
+        });
+        this.unbindDevice = ({ devices, }) => __awaiter(this, void 0, void 0, function* () {
+            const data = yield (0, devices_1.unbindDevice)({ devices });
+            if (data.success) {
+                this.getBindingList();
+            }
+            return data;
+        });
+        this.deviceSafetyRegister = ({ mac, productKey, }) => __awaiter(this, void 0, void 0, function* () {
+            return yield this.deviceSafetyApi({ mac, productKey, isReset: false });
+        });
+        this.deviceSafetyUnbind = ({ mac, productKey, }) => __awaiter(this, void 0, void 0, function* () {
+            return yield this.deviceSafetyApi({ mac, productKey, isReset: true });
+        });
+        this.setDeviceOnboardingDeploy = ({ ssid, bssid = '', password, mode = 0, timeout, isBind = true, softAPSSIDPrefix, eventCallBack }) => __awaiter(this, void 0, void 0, function* () {
+            if (this.currentWifiConfigHandle) {
+                return {
+                    success: false,
+                    err: errorCode_1.default.GIZ_SDK_DEVICE_CONFIG_IS_RUNNING,
+                };
+            }
+            const sTime = new Date().getTime();
+            GizLog_1.default.debug('GIZ_SDK: 配网开始时间:' + sTime, mode);
+            try {
+                switch (mode) {
+                    case 0: {
+                        this.currentWifiConfigHandle = new ap_1.default(ssid, bssid, password, this.specialProductKeys, this.specialProductKeySecrets);
+                        const data = yield this.currentWifiConfigHandle.setDeviceOnboardingDeploy({
+                            timeout,
+                            isBind,
+                            softAPSSIDPrefix,
+                            eventCallBack,
+                        });
+                        this.currentWifiConfigHandle = null;
+                        const eTime = new Date().getTime();
+                        GizLog_1.default.debug('GIZ_SDK: 配网结束时间:' + eTime);
+                        GizLog_1.default.debug('GIZ_SDK: 配网用时:' + (eTime - sTime));
+                        return data;
+                    }
+                    case 3: {
+                        this.currentWifiConfigHandle = new ble_2.default(ssid, bssid, password, this.specialProductKeys, this.specialProductKeySecrets, this.bleHandle);
+                        const data = yield this.currentWifiConfigHandle.setDeviceOnboardingDeploy({
+                            timeout,
+                            isBind,
+                            softAPSSIDPrefix,
+                            eventCallBack,
+                        });
+                        this.currentWifiConfigHandle = null;
+                        const eTime = new Date().getTime();
+                        GizLog_1.default.debug('GIZ_SDK: 配网结束时间:' + eTime);
+                        GizLog_1.default.debug('GIZ_SDK: 配网用时:' + (eTime - sTime));
+                        return data;
+                    }
+                    case 5: {
+                        const sysInfo = yield wx.getSystemInfoSync();
+                        console.log('sysInfosysInfo', sysInfo);
+                        if (sysInfo.platform !== 'android') {
+                            return {
+                                success: false,
+                                message: '只支持安卓'
+                            };
+                        }
+                        const cloudServiceInfo = (0, globalData_1.getGlobalData)('cloudServiceInfo');
+                        console.log('cloudServiceInfo', cloudServiceInfo);
+                        this.currentWifiConfigHandle = new nfc_1.default(ssid, bssid, password, this.specialProductKeys, this.specialProductKeySecrets, (cloudServiceInfo === null || cloudServiceInfo === void 0 ? void 0 : cloudServiceInfo.openAPIInfo) || 'api.gizwits.com');
+                        const data = yield this.currentWifiConfigHandle.setDeviceOnboardingDeploy({
+                            timeout,
+                            isBind,
+                            softAPSSIDPrefix,
+                            eventCallBack,
+                        });
+                        this.currentWifiConfigHandle = null;
+                        const eTime = new Date().getTime();
+                        GizLog_1.default.debug('GIZ_SDK: 配网结束时间:' + eTime);
+                        GizLog_1.default.debug('GIZ_SDK: 配网用时:' + (eTime - sTime));
+                        return data;
+                    }
+                }
+            }
+            catch (error) {
+                GizLog_1.default.error("GIZ_SDK: setDeviceOnboardingDeploy", error);
+                if (error.err &&
+                    error.err.errorCode) {
+                    return error;
+                }
+                return {
+                    success: false,
+                    err: errorCode_1.default.GIZ_SDK_OTHERWISE,
+                };
+            }
+            finally {
+                this.currentWifiConfigHandle = null;
+            }
+        });
+        this.setDomain = (cloudServiceInfo) => {
+            const openAPIInfo = (cloudServiceInfo && cloudServiceInfo.openAPIInfo) || 'api.gizwits.com';
+            const newData = Object.assign(Object.assign({}, (cloudServiceInfo || {})), { openAPIInfo });
+            (0, globalData_1.setGlobalData)('cloudServiceInfo', newData);
+        };
+        this.deviceSafetyApi = ({ mac, productKey, isReset, }) => __awaiter(this, void 0, void 0, function* () {
+            const target = (0, utils_1.getProductInfoThroughPK)(productKey, this.productInfo);
+            if (target) {
+                return yield (0, devices_1.safeRegister)({
+                    productKey,
+                    productSecret: target.productSecret,
+                    mac,
+                    isReset,
+                    passcode: '1234567890',
+                });
+            }
+            return {
+                success: false,
+                err: errorCode_1.default.GIZ_SDK_PRODUCTKEY_NOT_IN_SPECIFY,
+            };
+        });
+        this.getBindingList = () => __awaiter(this, void 0, void 0, function* () {
+            const data = yield (0, devices_1.getBindingList)();
+            this.deviceList = data.data || [];
+            this.notiDeviceList();
+            return data;
+        });
+        this.getDevices = () => __awaiter(this, void 0, void 0, function* () {
+            yield this.getBindingList();
+            return {
+                success: true,
+                data: this.allDevices,
+            };
+        });
+        this.stopDeviceOnboardingDeploy = () => {
+            if (this.currentWifiConfigHandle) {
+                this.currentWifiConfigHandle.stopDeviceOnboardingDeploy();
+                this.currentWifiConfigHandle = null;
+            }
+        };
+        this.setLogLevel = (level) => {
+            return GizLog_1.default.setLogLevel(level);
+        };
+        this.renameDevice = (device, name) => __awaiter(this, void 0, void 0, function* () {
+            if (!name) {
+                return {
+                    success: false,
+                    message: "please input device name"
+                };
+            }
+            if (device.isBind) {
+                return yield (0, devices_1.editBindInfo)({
+                    did: device.did,
+                    name: name,
+                });
+            }
+            return {
+                success: false,
+                message: "device not bind"
+            };
+        });
+        this.removeEventListener = (type, func) => {
+            if (this.listenerMap[type]) {
+                const index = this.listenerMap[type].indexOf(func);
+                if (index !== -1) {
+                    this.listenerMap[type].splice(index, 1);
+                    return {
+                        success: true,
+                    };
+                }
+            }
+            return {
+                success: false,
+            };
+        };
+        this.addEventListener = (type, func) => __awaiter(this, void 0, void 0, function* () {
+            if (!this.listenerMap[type]) {
+                this.listenerMap[type] = [];
+            }
+            if (this.listenerMap[type].indexOf(func) === -1) {
+                this.listenerMap[type].push(func);
+            }
+            return {
+                success: true,
+            };
+        });
+        this.destory = () => {
+            this.bleHandle.destory();
+            this.lanHandle.destory();
+            this.socketHandle.destory();
+            this.keepScanTimer && clearInterval(this.keepScanTimer);
+        };
+        this.init(props);
+    }
+    get bleHandle() {
+        if (!this._bleHandle) {
+            this._bleHandle = new ble_1.BleHandle({
+                pks: this.specialProductKeys,
+                offlineThreshold: this.offlineThreshold,
+            });
+        }
+        return this._bleHandle;
+    }
+    get lanHandle() {
+        if (!this._lanHandle) {
+            this._lanHandle = new lan_1.LanHandle({
+                pks: this.specialProductKeys,
+            });
+        }
+        return this._lanHandle;
+    }
+    get socketHandle() {
+        if (!this._gizSocket) {
+            this._gizSocket = new socket_1.default({
+                appID: (0, globalData_1.getGlobalData)('appID'),
+                token: (0, globalData_1.getGlobalData)('token'),
+                uid: (0, globalData_1.getGlobalData)('uid'),
+            });
+            this._gizSocket.subscribeDeviceStatus(this.handleSocketDeviceData);
+            this._gizSocket.subscribeBindingChanged(this.getBindingList);
+            this._gizSocket.subscribeSocketStatus(this.handleSocketStatus);
+        }
+        return this._gizSocket;
+    }
+    reInit(props) {
+        this.init(props);
+        this.lanHandle.pks = this.specialProductKeys;
+        this.bleHandle.pks = this.specialProductKeys;
+        this.bleHandle.offlineThreshold = props.offlineThreshold;
+        const { appID, token, cloudServiceInfo = { openAPIInfo: '' } } = props;
+        const openAPIInfo = (cloudServiceInfo && cloudServiceInfo.openAPIInfo) || 'api.gizwits.com';
+        if (appID !== (0, globalData_1.getGlobalData)('appID') ||
+            token !== (0, globalData_1.getGlobalData)('token') ||
+            openAPIInfo !== (0, globalData_1.getGlobalData)('cloudServiceInfo').openAPIInfo) {
+            this.socketHandle.destory();
+            this._gizSocket = null;
+            this.socketHandle;
+            this.getBindingList();
+        }
+    }
+    get specialProductKeys() {
+        return this.productInfo.map((item) => { var _a; return (_a = item.productKey) !== null && _a !== void 0 ? _a : ''; });
+    }
+    get specialProductKeySecrets() {
+        return this.productInfo.map((item) => { var _a; return (_a = item.productSecret) !== null && _a !== void 0 ? _a : ''; });
+    }
+}
+GizwitsMiniSDK.getVersion = () => {
+    return {
+        success: true,
+        data: version,
+    };
+};
+exports.default = GizwitsMiniSDK;