mini_program_gizwits_sdk 3.2.9 → 3.2.10-kuka

package/dist/src/{handler/ble.d.ts → ble.d.ts}

@@ -1,19 +1,5 @@
-import { wrapErrorInfo } from '../utils';
-import EventListener from './EventListener';
-declare type GizBleDeviceListotifications = (devices: IDevice[]) => void;
-declare type GizBleDeviceDataNotifications = (curDevice: WechatMiniprogram.OnBLECharacteristicValueChangeCallbackResult, hexString: string) => void;
-declare type GizBleErrorNotifications = (err: {
-    errCode: number;
-    errMsg: string;
-}) => void;
-export interface TBleHandleEvent {
-    GizBleDeviceData: GizBleDeviceDataNotifications;
-    GizBleDeviceList: GizBleDeviceListotifications;
-    GizBleError: GizBleErrorNotifications;
-}
-export interface GizwitsWxBlueToothDevice extends WechatMiniprogram.BlueToothDevice {
-    communicationType: 'BLE_BROADCAST' | 'BLE';
-}
+import { wrapErrorInfo } from './utils';
+import Sdk from './Sdk';
 interface BleHandleParams {
     serviceUUIDSuffix: string;
     characteristicUUIDSuffix: string;
@@ -32,34 +18,26 @@ interface ConnectDevice {
 interface ConstructorParams {
     pks: string[];
     bleHandleParams?: BleHandleParams;
+    globalListenerMap: object;
+    gizSdk: Sdk;
     offlineThreshold?: number;
 }
-export declare class BleHandle extends EventListener<TBleHandleEvent> {
+export declare class BleHandle {
     private serviceUUIDSuffix;
     connectedList: ConnectDevice[];
-    private connectingDevId;
     private pks;
-    private listenDevOfflineTimer;
-    private boradcastTimer;
-    private boradcastDataCache;
     private tmpBleData;
     private tmpDataNum;
-    private disableScanFlag;
-    private peripheralServer;
-    private isActive;
+    private listenerMap;
+    private globalListenerMap;
     scanList: IDevice[];
-    constructor({ pks, bleHandleParams, offlineThreshold, }: ConstructorParams);
-    private onBluetoothAdapterStateChange;
-    private onAppShow;
-    private onAppHide;
+    private gizSdk;
+    constructor({ pks, bleHandleParams, globalListenerMap, gizSdk, offlineThreshold, }: ConstructorParams);
     private listenDevOffline;
     private openBluetoothAdapter;
     private handleOnBLECharacteristicValueChange;
-    private notiDeviceDataToSdk;
     private notifyError;
-    private notifyDevices;
     private listenConnection;
-    private init;
     checkPermission: () => Promise<{
         data: {
             discovering: boolean;
@@ -71,40 +49,43 @@ export declare class BleHandle extends EventListener<TBleHandleEvent> {
         success: boolean;
     }>;
     private getBluetoothAdapterState;
-    getDeviceStatus: (deviceId: string, productKey: string, gwDid?: string, attrNames?: string[]) => Promise<import("../wechatApi").IWechatResult | {
+    getDeviceStatus: (deviceId: string, productKey: string, gwDid?: string, attrNames?: string[]) => Promise<import("./wechatApi").IWechatResult | {
         success: boolean;
         message: string;
+        errbody: {
+            serviceId: string;
+            characteristicId: string;
+        };
     } | {
         success: boolean;
     }>;
-    private updateDevice;
-    private updateCtime;
-    private checkDeviceIsChange;
     private handleBluetoothDeviceFound;
     startScan: (onScanDevice: OnScanDevice, delay?: number) => Promise<IStartScanResult>;
-    stopScan: () => Promise<any>;
-    disableScan: () => Promise<WechatMiniprogram.BluetoothError>;
-    enableScan: () => void;
+    stopScan: () => Promise<{
+        errMsg: string;
+        errCode: number;
+    }>;
     connectDevice: (deviceId: string) => Promise<{
         success: boolean;
         message: any;
     }>;
     private handleBindReq;
     private handleLoginReq;
-    watchBleDevice: (deviceId: any, func: any) => Promise<{
-        success: boolean;
+    removeDeviceListener: (deviceId: string, onDeviceStatusChange: any) => {
         message: string;
-    }>;
-    writeBoradcast: (bleDeviceID: string, value: number[]) => Promise<{
         success: boolean;
-        message: string;
-    } | {
+    };
+    addDeviceListener: (deviceId: any, onDeviceStatusChange: (curDevice: WechatMiniprogram.OnBLECharacteristicValueChangeCallbackResult, hexString: string) => void) => Promise<{
         success: boolean;
-        message?: undefined;
+        message: string;
     }>;
-    write: (bleDeviceID: string, value: ArrayBuffer) => Promise<import("../wechatApi").IWechatResult | {
+    write: (deviceId: string, value: ArrayBuffer) => Promise<import("./wechatApi").IWechatResult | {
         success: boolean;
         message: string;
+        errbody: {
+            serviceId: string;
+            characteristicId: string;
+        };
     }>;
     disConnectDevice: (deviceId: string) => Promise<{
         err: string;
@@ -112,6 +93,5 @@ export declare class BleHandle extends EventListener<TBleHandleEvent> {
     }>;
     private removeDevById;
     private getTargetDevice;
-    destory: () => void;
 }
 export {};

package/dist/src/productConfigFileManage.d.ts

@@ -7,7 +7,6 @@ declare class ProductConfigFileManage {
     key: string;
     init: () => Promise<void>;
     getConfigFile: (pk: string) => Promise<IDataPointConfig>;
-    getAttrItem: (pk: string, key: string) => Promise<import("./protocol/DataPoint").IDataPointAttr>;
 }
 declare const productConfigFileManage: ProductConfigFileManage;
 export default productConfigFileManage;

package/dist/src/protocol/DataPoint.d.ts

@@ -48,20 +48,5 @@ declare const unpack: (data: number[], pk: string) => Promise<{
     message: string;
     messageType: messageType;
 }>;
-declare const pack: (data: object, pk: string) => Promise<{
-    data: number[];
-    raw: {
-        header: number[];
-        flag: number[];
-        len: number[];
-        headerCmd: number[];
-        sn: number[];
-        cmd: number[];
-    };
-}>;
-declare const padBoradcastData: (data: number[]) => string;
-declare type TargetType = 'int' | 'string';
-declare const formatEnum: (attrs: any, pk: string, targetType: TargetType) => Promise<any>;
-declare type BTargetType = 'string' | 'object';
-declare const formatBinary: (attrs: any, pk: string, targetType: BTargetType) => Promise<any>;
-export { pack, unpack, padBoradcastData, formatEnum, formatBinary };
+declare const pack: (data: object, pk: string) => Promise<number[]>;
+export { pack, unpack };

package/dist/src/protocol/tool.d.ts

@@ -1,5 +1,4 @@
 declare const checkHeader: (data: any) => number | false;
-export declare const completeBlock: (cmd: string) => number[];
 declare const getProtocolLen: (data: any) => number;
 declare function arrayToString(arr: number[]): string;
 declare const fillString: (string: string, num: number, foot?: boolean) => string;
@@ -7,5 +6,4 @@ declare const string2Bytes: (str: string) => number[];
 declare const hexStrint2byte: (str: string) => number[];
 declare const formatCode: (str: any) => number[];
 declare const formatCodesFromStr: (str: string) => number[][];
-declare const arrayToUint8: (config: number[]) => Uint8Array;
-export { checkHeader, getProtocolLen, arrayToString, fillString, string2Bytes, hexStrint2byte, formatCodesFromStr, formatCode, arrayToUint8 };
+export { checkHeader, getProtocolLen, arrayToString, fillString, string2Bytes, hexStrint2byte, formatCodesFromStr, formatCode };

package/dist/src/sdk.d.ts

@@ -1,15 +1,6 @@
-import { TLogType } from './GizLog';
 import { ILoginRes } from './services/login';
 import { IOpenApiDevice, ISafeRegisterReturn, IUnbindReturn } from './services/devices';
 import { IDataPointConfig } from './protocol/DataPoint';
-interface SyncCallBackParams {
-    event: TSyncEvnet;
-    currentNum?: number;
-    totalNum?: number;
-    message?: string;
-}
-declare type TSyncEvnet = 'SYNC_START' | 'SYNC_END' | 'SYNC_FAIL' | 'SYNC_CANCEL' | 'SYNC_PROGRESS';
-export declare type SyncCallBack = (data: SyncCallBackParams) => void;
 interface ISDKResult<T> {
     data?: T;
     err?: IError;
@@ -90,82 +81,57 @@ interface GizwitsSdkOption {
     uid?: string;
     offlineThreshold?: number;
 }
-declare class GizwitsMiniSDK {
+declare class SDK {
     private version;
     private listenerMap;
-    private keepScanTimer;
     private _deviceList;
     private get deviceList();
     private set deviceList(value);
     private _bleDevices;
     get bleDevices(): IDevice[];
     set bleDevices(data: IDevice[]);
-    private _lanDevices;
-    private get lanDevices();
-    private set lanDevices(value);
+    private _udpDevices;
+    private get udpDevices();
+    private set udpDevices(value);
     private get allDevices();
+    private set allDevice(value);
     private get bleScanDevice();
     private productInfo;
     private currentWifiConfigHandle;
     private _bleHandle;
-    private _lanHandle;
+    private autoScanInterval;
     private _gizSocket;
     private offlineThreshold?;
-    private syncDataCallBack?;
-    private syncTotalNum;
-    private syncCurrnetNum;
-    private syncDataTimoutTimer;
-    private SYNC_TIMEOUT;
-    private syncDevice?;
     constructor({ appID, appSecret, productInfo, cloudServiceInfo, token, uid, offlineThreshold, }: GizwitsSdkOption);
     private get bleHandle();
-    private get lanHandle();
     private get socketHandle();
     get specialProductKeys(): string[];
     get specialProductKeySecrets(): string[];
-    private handleBleError;
-    private handleBleDevices;
-    handleLanDevices: (devices: IDevice[]) => void;
-    private handleLanDeviceData;
     private handleBleDeviceData;
     private handleSocketDeviceData;
     private handleSocketStatus;
     private notiDeviceList;
-    private initLan;
     startAutoScan: () => void;
     stopAutoScan: () => void;
-    setDeviceMeta: <K extends "did" | "mac" | "productKey" | "bleWorkStatus" | "name" | "isBind" | "rootDeviceId" | "bleDeviceID" | "remark" | "passcode" | "connectType" | "isOnline" | "isLanOnline" | "isBleOnline" | "host" | "wss_port" | "ctime">(curDev: IDevice, key: K, value: IDevice[K], force?: boolean) => void;
+    setDeviceMeta: <K extends "name" | "mac" | "productKey" | "did" | "bleWorkStatus" | "isBind" | "rootDeviceId" | "bleDeviceID" | "remark" | "connectType" | "isOnline" | "isLanOnline" | "isBleOnline" | "host" | "wss_port" | "ctime">(curDev: IDevice, key: K, value: IDevice[K]) => void;
     getVersion: () => {
         success: boolean;
         data: string;
     };
     initBle: () => Promise<ISDKResult<null>>;
     scanBleDevice: (delay: number) => Promise<ISDKResult<IDevice[]>>;
-    write: (device: IDevice, attrs: object) => Promise<import("./wechatApi").IWechatResult | {
-        success: boolean;
-        message: string;
-    } | {
-        success: boolean;
-        message?: undefined;
-    }>;
-    writeRaw: (device: IDevice, data: number[]) => Promise<IError | import("./wechatApi").IWechatResult | {
-        success: boolean;
-    }>;
-    setDeviceTimeStamp: (device: IDevice) => Promise<import("./wechatApi").IWechatResult | {
-        success: boolean;
-        message: string;
-    }>;
-    syncDeviceData: (device: IDevice, callback: SyncCallBack) => Promise<import("./wechatApi").IWechatResult | {
+    write: (device: IDevice, attrs: object) => Promise<{
         success: boolean;
         message: string;
     }>;
-    cancelSyncDeviceData: () => Promise<void>;
-    private cleanSyncDeviceData;
     getProductConfig: (pk: string) => Promise<ISDKResult<IDataPointConfig>>;
     stopScanBleDevice: () => void;
     login: (openID: string) => Promise<ISDKResult<ILoginRes>>;
     getDeviceStatus: (device: IDevice, attrNames?: string[]) => Promise<import("./wechatApi").IWechatResult | {
         success: boolean;
+    } | {
+        success: boolean;
+        message: string;
     }>;
     subscribe: (device: IDevice, connectType?: TConnectType, _autoGetDeviceStatus?: boolean) => Promise<{
         success: boolean;
@@ -173,8 +139,13 @@ declare class GizwitsMiniSDK {
     } | {
         success: boolean;
         errorCode: IError;
-    } | IResult<any>>;
+    } | {
+        success: boolean;
+    }>;
     unSubscribe: (device: IDevice) => Promise<{
+        err: string;
+        success: boolean;
+    } | {
         success: boolean;
     }>;
     bindRemoteDevice: ({ mac, productKey, alias, beOwner, }: IBindRemoteDeviceParams) => Promise<ISDKResult<IOpenApiDevice>>;
@@ -189,16 +160,11 @@ declare class GizwitsMiniSDK {
     getBindingList: () => Promise<import("./openApiRequest").IServiceResult<IDevice[]>>;
     getDevices: () => Promise<ISDKResult<IDevice[]>>;
     stopDeviceOnboardingDeploy: () => void;
-    setLogLevel: (level: TLogType) => {
-        success: boolean;
-        err: IError;
-    };
-    removeEventListener: <K extends "GizDeviceListNotifications" | "GizDeviceStatusNotifications" | "GizDeviceAttrsNotifications" | "onScanListChange" | "onBleHandleError">(type: K, func: TListenerType[K]) => {
+    removeEventListener: <K extends "onBleHandleError" | "GizDeviceListNotifications" | "GizDeviceStatusNotifications" | "GizDeviceAttrsNotifications" | "onScanListChange">(type: K, func: TListenerType[K]) => {
         success: boolean;
     };
-    addEventListener: <K extends "GizDeviceListNotifications" | "GizDeviceStatusNotifications" | "GizDeviceAttrsNotifications" | "onScanListChange" | "onBleHandleError">(type: K, func: TListenerType[K]) => Promise<{
+    addEventListener: <K extends "onBleHandleError" | "GizDeviceListNotifications" | "GizDeviceStatusNotifications" | "GizDeviceAttrsNotifications" | "onScanListChange">(type: K, func: TListenerType[K]) => Promise<{
         success: boolean;
     }>;
-    destory: () => void;
 }
-export default GizwitsMiniSDK;
+export default SDK;

package/dist/src/{handler/socket.d.ts → socket.d.ts}

@@ -1,10 +1,6 @@
 interface IRespError {
     err?: IError;
 }
-interface IWriteRes {
-    success: boolean;
-    message: string;
-}
 interface ICommonProps {
     appID: string;
     token: string;
@@ -29,11 +25,7 @@ export default class GizwitsWS {
     _onBindingChanged?: IEmptyFn;
     constructor({ appID, token, uid, limitSocketNum, }: IGWSProps);
     init(): Promise<IError>;
-    updateToken: ({ token, uid }: {
-        token: any;
-        uid: any;
-    }) => void;
-    _getDevice: (did: string) => IDevice | IError;
+    _getDevice: (did: string) => IError | IDevice;
     _getConnect: (device: IDevice) => Connection;
     _getDeviceAndConnect: (did: string) => IError | [IDevice, Connection];
     connectDevice: (device: IDevice) => {
@@ -43,20 +35,17 @@ export default class GizwitsWS {
         success: boolean;
         errorCode?: undefined;
     };
-    disConnectDevice: (device: IDevice) => {
-        success: boolean;
-    };
     connect: (did: string) => IError;
-    send: (did: string, raw: number[]) => IError | Promise<IWriteRes>;
-    writeData: (device: IDevice, attrs: ICommonObj) => Promise<IWriteRes> | {
+    send: (did: string, raw: Uint8Array[]) => IError | Promise<WechatMiniprogram.GeneralCallbackResult>;
+    writeData: (device: IDevice, attrs: ICommonObj) => {
         success: boolean;
     };
-    write: (did: string, attrs: ICommonObj) => IError | Promise<IWriteRes>;
+    write: (did: string, attrs: ICommonObj) => IError | Promise<WechatMiniprogram.GeneralCallbackResult>;
     readStatus: (device: IDevice, names?: string[]) => {
         success: boolean;
     };
-    read: (did: string, names?: string[]) => IError | Promise<IWriteRes>;
-    destory: () => void;
+    read: (did: string, names?: string[]) => IError | Promise<WechatMiniprogram.GeneralCallbackResult>;
+    close: () => void;
     subscribeDeviceStatus: (cb: IOnDeviceStatusChanged) => void;
     subscribeBindingChanged: (cb: IEmptyFn) => void;
     subscribeSocketStatus: (cb: IOnSocketStatusChanged) => void;
@@ -94,17 +83,13 @@ export declare class Connection {
     _onBindingChanged?: IEmptyFn;
     _onSocketStatusChanged?: IOnSocketStatusChanged;
     _waitSends: object[];
-    _checkConnectTimerId?: any;
     constructor({ appID, token, uid, wsInfo, onDeviceStatusChanged, onBindingChanged, onSocketStatusChanged, }: IConnectProps);
-    destory: () => void;
-    _networkChange: (res: WechatMiniprogram.OnNetworkStatusChangeCallbackResult) => Promise<void>;
-    _appShow: () => Promise<void>;
+    _networkChange: (res: WechatMiniprogram.OnNetworkStatusChangeCallbackResult) => void;
+    _appShow: () => void;
     _addSubDid: (did: any) => void;
-    _removeSubDid: (did: any) => void;
     _connectWS: () => void;
     _subDevices: (dids: string[]) => void;
-    _unSubDevices: (dids: string[]) => void;
-    _send: (data: object, forced?: boolean) => Promise<IWriteRes>;
+    _send: (data: object, forced?: boolean) => Promise<WechatMiniprogram.GeneralCallbackResult>;
     close: () => void;
     handleClose: (res: {
         code: number;
@@ -132,8 +117,7 @@ export declare class Connection {
     }) => void;
     _rawChangedResp: (data: IDeviceRawStatusChangedProps) => void;
     _statusChangedResp: (data: IDeviceStatusChangedProps) => void;
-    _isSub: (did: string) => boolean;
     _invalidMsgResp: (data: any) => void;
-    _bindingChangedResp: (data: any) => void;
+    _bindingChangedResp: () => void;
 }
 export {};

package/dist/src/utils.d.ts

@@ -1,5 +1,4 @@
 import { IProductInfo } from './sdk';
-import { GizwitsWxBlueToothDevice } from './handler/ble';
 export declare function ab2hex(buffer: ArrayBuffer): any;
 export declare function compareWXSDKVersion(v1: string, v2: string): 0 | 1 | -1;
 export declare const isError: (err: unknown) => err is IError;
@@ -23,25 +22,9 @@ export declare const advertisData2PkAndMac: (advertisData: ArrayBuffer, pks: str
 export declare const isSameDevice: (deviceA: IDevice, deviceB: IDevice) => boolean;
 export declare const merageBleLocalDevices: (mainDevice: IDevice[], localDevice: IDevice[]) => IDevice[];
 export declare const merageLanLocalDevices: (mainDevice: IDevice[], localDevice: IDevice[]) => IDevice[];
-export declare const BTDevice2GDevice: (BTDevice: GizwitsWxBlueToothDevice, pks: string[]) => IDevice;
+export declare const BTDevice2GDevice: (BTDevice: WechatMiniprogram.BlueToothDevice, pks: string[]) => IDevice;
 export declare const getFirstConnectType: (device: IDevice, type?: TConnectType) => TConnectType;
 export declare const getProductInfoThroughPK: (pk: string, productInfos: IProductInfo[]) => IProductInfo;
 export declare const mergeObject: (obj1: any, obj2: any) => any;
 export declare function hex2ab(str: any): Uint8Array;
-declare type BroadcastCmd = 0x19 | 0x94;
-declare type TBoradcastRes = {
-    mac: string;
-    cmd: BroadcastCmd;
-    data: string[];
-};
-export declare function parseBroadcastData(data: number[]): TBoradcastRes;
-export declare function ab2numbers(buffer: ArrayBuffer): any;
-export declare function encrypt(uuids: number[], key: number): string[];
-export declare const convertToServiceUuids: ({ len, data, index, mac }: {
-    len?: any;
-    data?: any;
-    index?: number;
-    mac: any;
-}) => any;
-export declare function convertToUuids(mac: number, sn: number, data: number[]): string[];
 export {};

package/dist/src/wechatApi.d.ts

@@ -6,13 +6,10 @@ export interface IWechatResult {
     errMsg: string;
     errCode: number;
 }
-export declare function retryConnect(deviceId: string, timeout?: number): Promise<IWechatResult | {
-    success: boolean;
-}>;
 export declare function openBluetoothAdapter(): Promise<IWechatResult>;
 export declare function closeBluetoothAdapter(): Promise<IWechatResult>;
 export declare function getBluetoothAdapterState(): Promise<IBluetoothAdapterStateResult>;
-export declare function startBluetoothDevicesDiscovery(allowDuplicatesKey?: boolean): Promise<IWechatResult>;
+export declare function startBluetoothDevicesDiscovery(): Promise<IWechatResult>;
 export declare function getBluetoothDevices(): Promise<WechatMiniprogram.BlueToothDevice[]>;
 export declare function createBLEConnection(deviceId: string, timeout: number): Promise<IWechatResult>;
 interface IBLEService {

package/dist/src/wifiConfig/ble.d.ts

@@ -1,14 +1,12 @@
 import { IRandomCodesResult, IResult } from "../sdk";
 import ConfigBase from "./ConfigBase";
-import { BleHandle } from "../handler/ble";
 interface IArgs {
     bleDeviceId: string;
     arrayBuffer: ArrayBuffer;
     serviceUUIDSuffix?: string;
     characteristicUUIDSuffix?: string;
-    bleHandle: BleHandle;
 }
-export declare function sendBLEConfigCmd({ bleDeviceId, arrayBuffer, serviceUUIDSuffix, characteristicUUIDSuffix, bleHandle }: IArgs): Promise<boolean | void>;
+export declare function sendBLEConfigCmd({ bleDeviceId, arrayBuffer, serviceUUIDSuffix, characteristicUUIDSuffix, }: IArgs): Promise<boolean | void>;
 interface configBLEDeviceParams {
     ssid: string;
     password: string;
@@ -21,8 +19,6 @@ interface ISetDeviceOnboardingDeployProps {
     softAPSSIDPrefix: string;
 }
 declare class BLEConfig extends ConfigBase {
-    bleHandle: BleHandle;
-    constructor(ssid: string, password: string, specialProductKeys: string[], specialProductKeySecrets: string[], bleHandle: BleHandle);
     destroy: () => void;
     isValidBleDevice: (bleDevice: WechatMiniprogram.BlueToothDevice, softAPSSIDPrefix?: string) => boolean;
     enableBluetoothDevicesDescovery: () => Promise<{

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mini_program_gizwits_sdk",
-  "version": "3.2.9",
+  "version": "3.2.10-kuka",
   "description": "增加离线数据同步",
   "main": "./dist/index.js",
   "scripts": {

package/src/handler/ble.ts

@@ -91,8 +91,8 @@ export class BleHandle extends EventListener<TBleHandleEvent> {
   constructor({
     pks = [],
     bleHandleParams = {
-      serviceUUIDSuffix: 'abf0',
-      characteristicUUIDSuffix: 'abf7',
+      serviceUUIDSuffix: 'fe60',
+      characteristicUUIDSuffix: 'fe61',
     },
     offlineThreshold,
   }: ConstructorParams) {
@@ -195,7 +195,6 @@ export class BleHandle extends EventListener<TBleHandleEvent> {
     if (!curDevice.value) {
       return;
     }
-    console.log('handleOnBLECharacteristicValueChange', curDevice)
     const hexString = ab2hex(curDevice.value);
     try {
       const data = new ProtocolBase(hexStrint2byte(hexString));
@@ -469,7 +468,8 @@ export class BleHandle extends EventListener<TBleHandleEvent> {
 
       GizLog.debug("GIZ_SDK: start scan", delay);
       await wx.startBluetoothDevicesDiscovery({
-        services: ['ABF8', 'ABF0', 'F0AB', 'F8AB'],
+        services: [],
+
         powerLevel: 'high',
         allowDuplicatesKey: true,
         interval: 200,
@@ -576,31 +576,31 @@ export class BleHandle extends EventListener<TBleHandleEvent> {
         })
         .catch((err) => this.notifyError(err));
 
-      this.write(deviceId, numberArray2Uint8Array(Bind.pack()).buffer);
-      const data = await this.handleBindReq(deviceId);
-      GizLog.log('handleBindReq', data);
-
-      if (data.success) {
-        this.write(
-          deviceId,
-          numberArray2Uint8Array(Login.pack({ passcode: data.data })).buffer
-        );
-        const loginData = (await this.handleLoginReq(deviceId).catch((err) =>
-          this.notifyError(err)
-        )) as any;
-        if (loginData?.success) {
-          
-          return {
-            success: true,
-            message: 'ok',
-          };
-        }
-      }
-
-      // 绑定失败，异常退出断开蓝牙
-      await wx.closeBLEConnection({
-        deviceId,
-      });
+      // this.write(deviceId, numberArray2Uint8Array(Bind.pack()).buffer);
+      // const data = await this.handleBindReq(deviceId);
+      // GizLog.log('handleBindReq', data);
+
+      // if (data.success) {
+      //   this.write(
+      //     deviceId,
+      //     numberArray2Uint8Array(Login.pack({ passcode: data.data })).buffer
+      //   );
+      //   const loginData = (await this.handleLoginReq(deviceId).catch((err) =>
+      //     this.notifyError(err)
+      //   )) as any;
+      //   if (loginData?.success) {
+
+      //     return {
+      //       success: true,
+      //       message: 'ok',
+      //     };
+      //   }
+      // }
+
+      // // 绑定失败，异常退出断开蓝牙
+      // await wx.closeBLEConnection({
+      //   deviceId,
+      // });
 
       return {
         success: false,

package/src/sdk.ts

@@ -404,6 +404,26 @@ class GizwitsMiniSDK {
         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) {
+              uploadP0({
+                device: target, 
+                data: [
+                  {
+                    raw: hexString,
+                    created_at: parseInt(`${Date.now() / 1000}`, 10)
+                  }
+                ],
+                productSecret: productConfig.productSecret,
+              }).then(data => {
+                console.debug('uploadP0 res', data)
+              })
+            }
+            
+          }
           const data = await unpack(hexStrint2byte(hexString), target.productKey);
           // 如果有kydata 则上报
           if (data?.kvData && this.listenerMap['GizDeviceAttrsNotifications']) {
@@ -454,17 +474,21 @@ class GizwitsMiniSDK {
           GizLog.debug("设备上报离线数据:payload", syncPackageData.payload)
           GizLog.debug("设备上报离线数据:timestemp", syncPackageData.timestemp)
 
-          const uploadRes = await uploadP0({
-            device: this.syncDevice,
-            data: [
-              {
-                raw: arrayToString(syncPackageData.payload),
-                created_at: syncPackageData.timestemp
-              }
-            ]
-          })
-
-          GizLog.debug("上传离线数据结果", uploadRes)
+          const productConfig = this.productInfo.find(item => item.productKey === this.syncDevice.productKey)
+          if(productConfig) {
+            const uploadRes = await uploadP0({
+              device: this.syncDevice,
+              data: [
+                {
+                  raw: arrayToString(syncPackageData.payload),
+                  created_at: syncPackageData.timestemp
+                }
+              ],
+              productSecret: productConfig.productSecret
+            })
+            GizLog.debug("上传离线数据结果", uploadRes)
+          }
+          
           this.syncCurrnetNum += 1;
           // 通知设备删除
           this.syncDataCallBack({
@@ -933,8 +957,13 @@ class GizwitsMiniSDK {
         // 连接BLE
         const data = await this.bleHandle.connectDevice(target.bleDeviceID);
         if (data.success) {
+          
           // 蓝牙设备比较特殊，在get 里面从bleHandle里找到连接的设备，再把connectType 设置成BLE，所以这里更新metaData 要强制更新并推送
           this.setDeviceMeta(target, 'connectType', 'BLE', true);
+          setTimeout(() => {
+            // 蓝牙设备连接成功之后默认设置一次ntp
+            this.setDeviceTimeStamp(target)
+          }, 250)
           setTimeout(() => {
             this.getDeviceStatus(target);
           }, 500);