mini_program_gizwits_sdk 3.2.4 → 3.2.6

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

@@ -0,0 +1,5 @@
+import ProtocolBase from "./ProtocolBase";
+declare class Ntp extends ProtocolBase {
+    static pack: () => number[];
+}
+export default Ntp;

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

@@ -0,0 +1,23 @@
+import ProtocolBase from "./ProtocolBase";
+export declare class RequestSync extends ProtocolBase {
+    state: number;
+    len: number;
+    constructor(data: number[]);
+    static pack: () => number[];
+}
+export declare class SyncPackage extends ProtocolBase {
+    id: number;
+    timestemp: number;
+    payloadLen: number;
+    payload: number[];
+    constructor(data: number[]);
+    static pack: (id: number) => number[];
+}
+export declare class DeletePackage extends ProtocolBase {
+    static pack: (id: number) => number[];
+}
+export declare class CancelSync extends ProtocolBase {
+    state: number;
+    constructor(data: number[]);
+    pack: () => number[];
+}

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

@@ -1,4 +1,5 @@
 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;

package/dist/src/sdk.d.ts

@@ -2,6 +2,14 @@ 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;
@@ -103,6 +111,12 @@ declare class GizwitsMiniSDK {
     private _lanHandle;
     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();
@@ -120,23 +134,33 @@ declare class GizwitsMiniSDK {
     private initLan;
     startAutoScan: () => void;
     stopAutoScan: () => void;
-    setDeviceMeta: <K extends "did" | "mac" | "productKey" | "bleWorkStatus" | "name" | "isBind" | "rootDeviceId" | "bleDeviceID" | "remark" | "connectType" | "isOnline" | "isLanOnline" | "isBleOnline" | "host" | "wss_port" | "ctime">(curDev: IDevice, key: K, value: IDevice[K], force?: boolean) => 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;
     getVersion: () => {
         success: boolean;
         data: string;
     };
     initBle: () => Promise<ISDKResult<null>>;
     scanBleDevice: (delay: number) => Promise<ISDKResult<IDevice[]>>;
-    write: (device: IDevice, attrs: object) => Promise<{
+    write: (device: IDevice, attrs: object) => Promise<import("./wechatApi").IWechatResult | {
+        success: boolean;
+        message: string;
+    } | {
         success: boolean;
         message?: undefined;
-    } | import("./wechatApi").IWechatResult | {
+    }>;
+    writeRaw: (device: IDevice, data: number[]) => Promise<IError | import("./wechatApi").IWechatResult | {
+        success: boolean;
+    }>;
+    setDeviceTimeStamp: (device: IDevice) => Promise<import("./wechatApi").IWechatResult | {
         success: boolean;
         message: string;
     }>;
-    writeRaw: (device: IDevice, data: number[]) => Promise<IError | import("./wechatApi").IWechatResult | {
+    syncDeviceData: (device: IDevice, callback: SyncCallBack) => Promise<import("./wechatApi").IWechatResult | {
         success: boolean;
+        message: string;
     }>;
+    cancelSyncDeviceData: () => Promise<void>;
+    private cleanSyncDeviceData;
     getProductConfig: (pk: string) => Promise<ISDKResult<IDataPointConfig>>;
     stopScanBleDevice: () => void;
     login: (openID: string) => Promise<ISDKResult<ILoginRes>>;

package/dist/src/services/uploadP0.d.ts

@@ -0,0 +1,12 @@
+export interface IUploadRes {
+}
+interface IData {
+    raw: string;
+    created_at: number;
+}
+interface IProps {
+    device: IDevice;
+    data: IData[];
+}
+export declare function uploadP0({ device, data }: IProps): Promise<import("../openApiRequest").IServiceResult<IUploadRes>>;
+export {};

package/global.d.ts

@@ -25,4 +25,4 @@ type TModeOfOperation = {
 declare namespace aesjs {
   const utils: TUtils;
   const ModeOfOperation: TModeOfOperation;
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mini_program_gizwits_sdk",
-  "version": "3.2.4",
+  "version": "3.2.6",
   "description": "优化扫描策略，根据UUID过滤，数据包也更新蓝牙设备的ctime",
   "main": "./dist/index.js",
   "scripts": {

package/src/global.d.ts

@@ -39,6 +39,7 @@ interface IDevice {
   rootDeviceId?: string;
   bleDeviceID?: string;
   remark?: string;
+  passcode?: string;
   connectType: TConnectType;
   isOnline: boolean; // 代表大循环在线
   isLanOnline: boolean; // 代表小循环在线

package/src/handler/ble.ts

@@ -14,7 +14,6 @@ import { hexStrint2byte } from '../protocol/tool';
 import ProtocolBase from '../protocol/ProtocolBase';
 import Login from '../protocol/Login';
 import GetDeviceStatus from '../protocol/GetDeviceStatus';
-import Sdk from '../Sdk';
 import { padBoradcastData } from '../protocol/DataPoint';
 import GizLog from '../GizLog';
 import EventListener from './EventListener';
@@ -189,7 +188,7 @@ export class BleHandle extends EventListener<TBleHandleEvent> {
     });
   };
 
-  private handleOnBLECharacteristicValueChange = (
+  private handleOnBLECharacteristicValueChange = async (
     curDevice: WechatMiniprogram.OnBLECharacteristicValueChangeCallbackResult
   ) => {
     // 不存在数据
@@ -470,7 +469,7 @@ export class BleHandle extends EventListener<TBleHandleEvent> {
 
       GizLog.debug("GIZ_SDK: start scan", delay);
       await wx.startBluetoothDevicesDiscovery({
-        services: ['ABF8', 'ABF0'],
+        services: ['ABF8', 'ABF0', 'F0AB', 'F8AB'],
         powerLevel: 'high',
         allowDuplicatesKey: true,
         interval: 200,

package/src/protocol/Ntp.ts

@@ -0,0 +1,13 @@
+import ProtocolBase from "./ProtocolBase";
+import { completeBlock } from "./tool";
+
+class Ntp extends ProtocolBase {
+  static pack = () => {
+    const time = parseInt(`${Date.now() / 1000}`, 10);
+    const timeString = time.toString(2)
+    
+    return [0,0,0,3,11,0,0,89].concat(completeBlock(timeString));
+  }
+}
+
+export default Ntp;

package/src/protocol/OffLineData.ts

@@ -0,0 +1,78 @@
+import ProtocolBase from "./ProtocolBase";
+import { arrayToString, completeBlock, fillString, hexStrint2byte } from "./tool";
+
+export class RequestSync extends ProtocolBase {
+  state: number = 0; // 0 允许同步 1 没有数据 2其他
+  len: number = 0; // 需要同步的数据长度
+  constructor(data: number[]) {
+    super(data);
+    let index = 0
+    this.state = this.content[0];
+    index += 1
+    this.len = parseInt(arrayToString(this.content.slice(index, index + 2)), 16);
+  }
+  static pack = () => {
+    return [0,0,0,3,3,0,0,81];
+  }
+}
+
+
+export class SyncPackage extends ProtocolBase {
+  id: number = 0;
+  timestemp: number = 0;
+  payloadLen: number = 0;
+  payload: number[] = []; 
+  constructor(data: number[]) {
+    super(data);
+
+    let index = 0;
+    this.id = parseInt(arrayToString(this.content.slice(index, index + 4)), 16);
+    
+    index += 4;
+
+    this.timestemp = parseInt(arrayToString(this.content.slice(index, index + 5)), 16);
+    index += 5;
+
+    this.payloadLen = parseInt(arrayToString(this.content.slice(index, index + 2)), 16);
+    index += 2;
+
+    this.payload = this.content.slice(index, this.content.length)
+  }
+  static pack = (id: number) => {
+    let stringData = id.toString(2)
+    stringData = fillString(stringData, 8 * 2)
+    const packageData = [0,0,0,3, 5].concat([0,0,83]).concat(completeBlock(stringData))
+    return packageData;
+  }
+}
+
+// 删除数据
+export class DeletePackage extends ProtocolBase {
+  static pack = (id: number) => {
+    let stringData = id.toString(2)
+    stringData = fillString(stringData, 8 * 2)
+    const packageData = [0,0,0,3,5].concat([0,0,85]).concat(completeBlock(stringData))
+    return packageData;
+  }
+}
+// let time = 1669711410;
+// let timeBytes: any = time.toString(16)
+// timeBytes = fillString(timeBytes, 10)
+// timeBytes = hexStrint2byte(timeBytes)
+// console.log(timeBytes)
+
+// const syncPackage = new SyncPackage([0,0,0,3,15 ,0, 0, 83,1,1,1,1].concat(timeBytes).concat([0, 1, 1]))
+// console.log(syncPackage)
+
+
+export class CancelSync extends ProtocolBase {
+  state: number = 0; // 0 同步完成 01 异常 02 其他
+  constructor(data: number[]) {
+    super(data);
+    this.state = this.content[0];
+  }
+  pack = () => {
+    const packageData = [0,0,0,3, 2, 0, 0, 87]
+    return packageData;
+  }
+}

package/src/protocol/dataPoint.ts

@@ -1,5 +1,5 @@
 import productConfigFileManage from "../productConfigFileManage";
-import { arrayToString, checkHeader, fillString, getProtocolLen, hexStrint2byte } from "./tool";
+import { arrayToString, checkHeader, fillString, getProtocolLen, hexStrint2byte, completeBlock} from "./tool";
 
 export interface IDataPointConfig {
   name: string;
@@ -44,16 +44,6 @@ export interface IDataPointAttr {
   desc: string;
 }
 
-// 从协议计算一个区块的数据
-const completeBlock = (cmd: string) => {
-  // 补0到8的倍数
-  const newCmd = fillString(cmd, Math.ceil(cmd.length / 8) * 8);
-  const data: number[] = [];
-  for (let i = 0; i < newCmd.length; i += 8) {
-    data.push(parseInt(newCmd.substring(i, i + 8), 2));
-  }
-  return data;
-};
 const fixType = (type: TDataType) => {
   return type.indexOf('uint') !== -1 ? 'number' : type;
 };
@@ -284,15 +274,6 @@ const DataPointToP = ({ config, data, isAdaptiveDatapoint }: IDataPointToP0Param
     }
   };
 };
-
-/**
- * p0 转json
- * @param {*} config
- * @param {*} data
- * 设备到app
- * header len flag cmd sn action data
- * action 0x04定长上报 0x05定长下发 0x11变长下发 0x14变长上报 0x12变长下发读数据点 0x02定长读数据点
- */
  
 interface IPToDataPointParams {
   config: IDataPointAttr[];
@@ -323,6 +304,14 @@ function getVariableLength(data: number[]) {
   return lengthArr;
 }
 
+/**
+ * p0 转json
+ * @param {*} config
+ * @param {*} data
+ * 设备到app
+ * header len flag cmd sn action data
+ * action 0x04定长上报 0x05定长下发 0x11变长下发 0x14变长上报 0x12变长下发读数据点 0x02定长读数据点
+ */
 function PToDataPoint({ config = [], data }: IPToDataPointParams) {
   let action: number;
   let message = '';

package/src/protocol/tool.ts

@@ -9,6 +9,17 @@ const checkHeader = (data) => {
   return pointer;
 };
 
+// 从2进制，转换成10进制数组
+export const completeBlock = (cmd: string) => {
+  // 补0到8的倍数
+  const newCmd = fillString(cmd, Math.ceil(cmd.length / 8) * 8);
+  const data: number[] = [];
+  for (let i = 0; i < newCmd.length; i += 8) {
+    data.push(parseInt(newCmd.substring(i, i + 8), 2));
+  }
+  return data;
+};
+
 const getProtocolLen = (data) => {
   /**
    * 插入len

package/src/sdk.ts

@@ -26,8 +26,23 @@ import {
 } from './utils';
 import productConfigFileManage from './productConfigFileManage';
 import { formatEnum, IDataPointConfig, pack, unpack } from './protocol/DataPoint';
-import { hexStrint2byte } from './protocol/tool';
+import { arrayToString, hexStrint2byte } from './protocol/tool';
 import { LanHandle } from './handler/lan';
+import ProtocolBase from './protocol/ProtocolBase';
+import { CancelSync, DeletePackage, RequestSync, SyncPackage } from './protocol/OffLineData';
+import { uploadP0 } from './services/uploadP0';
+import sleep from './sleep';
+import Ntp from './protocol/Ntp';
+
+interface SyncCallBackParams {
+  event: TSyncEvnet;
+  currentNum?: number;
+  totalNum?: number;
+  message?: string;
+}
+type TSyncEvnet = 'SYNC_START' | 'SYNC_END' | 'SYNC_FAIL' | 'SYNC_CANCEL' | 'SYNC_PROGRESS';
+export type SyncCallBack = (data: SyncCallBackParams) => void
+
 
 // 接口返回格式
 interface ISDKResult<T> {
@@ -240,6 +255,14 @@ class GizwitsMiniSDK {
   private _gizSocket: GizwitsWS;
   private offlineThreshold?: number;
 
+  // 离线同步
+  private syncDataCallBack?: SyncCallBack = null
+  private syncTotalNum: number = 0
+  private syncCurrnetNum: number = 0
+  private syncDataTimoutTimer: any = null;
+  private SYNC_TIMEOUT: number = 4 * 60 * 1000
+  private syncDevice?: IDevice;
+
   constructor({
     appID,
     appSecret,
@@ -271,6 +294,22 @@ class GizwitsMiniSDK {
      * 初始化sdk的时候就要开始扫描设备
      */
     this.initLan();
+
+
+    // uploadP0({
+    //   device: {
+    //     productKey: "8915df8a1f074d52a38bd074d6da5ce1",
+    //     did: "7NHzru2BxYL5lamNHxfEbe",
+    //     passcode: "1234567890",
+    //   },
+    //   data: [
+    //     {
+    //       raw: "A",
+    //       created_at: 1669791627
+    //     }
+    //   ]
+    // })
+    
   }
 
   private get bleHandle() {
@@ -358,15 +397,120 @@ class GizwitsMiniSDK {
       (item) => item.bleDeviceID === curDevice.deviceId
     );
     if (target) {
-      const data = await unpack(hexStrint2byte(hexString), target.productKey);
-      // 如果有kydata 则上报
-      if (data?.kvData && this.listenerMap['GizDeviceAttrsNotifications']) {
-        this.listenerMap['GizDeviceAttrsNotifications'].map((item) => {
-          item({
-            device: target,
-            data: data?.kvData,
-          });
-        });
+      const bleBytesData = hexStrint2byte(hexString)
+      const parseData = new ProtocolBase(bleBytesData);
+      switch (parseData.cmd) {
+        case '0093':
+        case '0094':
+        case '0090':
+        case '0091': {
+          const data = await unpack(hexStrint2byte(hexString), target.productKey);
+          // 如果有kydata 则上报
+          if (data?.kvData && this.listenerMap['GizDeviceAttrsNotifications']) {
+            this.listenerMap['GizDeviceAttrsNotifications'].map((item) => {
+              item({
+                device: target,
+                data: data?.kvData,
+              });
+            });
+          }
+          break
+        }
+        case '0052': {
+          // 设备回复是否允许同步数据
+          if (!this.syncDataCallBack) break;
+          const requestSyncData = new RequestSync(bleBytesData)
+          GizLog.debug("设备回复是否允许同步， state:" , requestSyncData.state)
+
+          if (requestSyncData.state === 0) {
+            // 开始同步
+            this.syncCurrnetNum = 0;
+            this.syncTotalNum = requestSyncData.len;
+            this.syncDataCallBack({
+              event: 'SYNC_START',
+              totalNum: this.syncTotalNum,
+              currentNum: this.syncCurrnetNum
+            })
+            // 读取第0条
+            GizLog.debug("查询第一条离线数据")
+            await this.bleHandle.write(curDevice.deviceId, numberArray2Uint8Array(SyncPackage.pack(0)).buffer)
+          } else {
+            GizLog.debug("设备返回状态为1，同步失败")
+
+            // 同步失败
+            this.syncDataCallBack({
+              event: 'SYNC_FAIL',
+            })
+          }
+          break
+        }
+        case '0054': {
+          if (!this.syncDataCallBack) break;
+          // 设备上报需要同步的数据
+          GizLog.debug("设备上报离线数据")
+
+          const syncPackageData = new SyncPackage(bleBytesData)
+          const deletePackageCmd = DeletePackage.pack(syncPackageData.id)
+          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)
+          this.syncCurrnetNum += 1;
+          // 通知设备删除
+          this.syncDataCallBack({
+            event: "SYNC_PROGRESS",
+            totalNum: this.syncTotalNum,
+            currentNum: this.syncCurrnetNum
+          })
+
+          GizLog.debug("通知设备删除：", syncPackageData.id)
+          await this.bleHandle.write(curDevice.deviceId, numberArray2Uint8Array(deletePackageCmd).buffer)
+          await sleep(100)
+          // 查询新数据
+          if (syncPackageData.id < this.syncTotalNum - 1) {
+            GizLog.debug("查询新数据：", syncPackageData.id + 1)
+            await this.bleHandle.write(curDevice.deviceId, numberArray2Uint8Array(SyncPackage.pack(syncPackageData.id + 1)).buffer)
+          } else {
+            // 已经同步完数据，等设备回掉
+            GizLog.debug("sync success wait device callback")
+          }
+          break
+        }
+        case '0058': {
+          if (!this.syncDataCallBack) break;
+          // 设备上报停止同步
+
+          const cancelData = new CancelSync(bleBytesData)
+          GizLog.debug("设备上报停止同步 state:", cancelData.state )
+
+          if (cancelData.state === 0) {
+            // 同步完成
+            this.syncDataCallBack({
+              event: "SYNC_END",
+            })
+          } else {
+            this.syncDataCallBack({
+              event: "SYNC_FAIL",
+            })
+          }
+          // 清除相关数据
+          this.cleanSyncDeviceData();
+          break
+        }
+        case '0060': {
+          // NTP回复
+          break
+        }
       }
     }
   };
@@ -618,6 +762,78 @@ class GizwitsMiniSDK {
     };
   };
 
+  // 设置设备的时间戳
+  setDeviceTimeStamp = async (device: IDevice) => {
+    const target = this.allDevices.find((item) => isSameDevice(item, device));
+    if (!target) {
+      return { success: false, message: 'target is undefind' };
+    }
+
+    const data = Ntp.pack()
+
+    switch (target.connectType) {
+      case 'BLE': {
+        return this.bleHandle.write(device.bleDeviceID, numberArray2Uint8Array(data).buffer)
+      }
+    }
+    return {
+      success: false,
+      message: 'the connectType not support set timestamp'
+    }
+  }
+
+  // 同步蓝牙设备的离线数据
+  syncDeviceData =async (device: IDevice, callback: SyncCallBack) => {
+    const target = this.allDevices.find((item) => 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': {
+        GizLog.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 = RequestSync.pack();
+        // 发送开始同步的指令
+        this.syncDevice = {...target}
+        GizLog.debug("sent RequestSync data");
+        return this.bleHandle.write(device.bleDeviceID, numberArray2Uint8Array(data).buffer)
+      }
+    }
+    return {
+      success: false,
+      message: 'the connectType not support sync data'
+    }
+  }
+
+  public cancelSyncDeviceData =async () => {
+    this.cleanSyncDeviceData();
+  }
+
+  private 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)
+  }
+
   getProductConfig = async (
     pk: string
   ): Promise<ISDKResult<IDataPointConfig>> => {
@@ -1038,5 +1254,4 @@ class GizwitsMiniSDK {
     this.keepScanTimer && clearInterval(this.keepScanTimer);
   };
 }
-
-export default GizwitsMiniSDK;
+export default GizwitsMiniSDK;

package/src/services/devices.ts

@@ -45,6 +45,7 @@ export const getBindingList = async (): Promise<IServiceResult<IDevice[]>> => {
         port: item.port,
         ws_port: item.ws_port,
         wss_port: item.wss_port,
+        passcode: item.passcode,
         isBleOnline: false,
         isLanOnline: false,
         connectType: 'NONE',

package/src/services/uploadP0.ts

@@ -0,0 +1,28 @@
+import openApiRequest from "../openApiRequest";
+
+export interface IUploadRes {
+}
+
+interface IData {
+  raw: string;
+  created_at: number;
+} 
+
+interface IProps {
+  device: IDevice;
+  data: IData[];
+}
+export async function uploadP0 ({device, data}: IProps) {
+  const path = `/v2/products/${device.productKey}/devices/offline-data`;
+  return openApiRequest<IUploadRes>(path, {
+    data: {
+      data,
+      encoding: 'hex',
+    },
+    method: 'POST',
+    headers: {
+      'X-Gizwits-Device-Id': device.did,
+      'X-Gizwits-Device-passcode': device.passcode,
+    },
+  }, false)
+}