mini_program_gizwits_sdk 3.0.1 → 3.0.6

package/src/openApiRequest.ts

@@ -0,0 +1,103 @@
+import request from './request';
+import { getGlobalData } from "./globalData";
+import errorCode from './errorCode';
+
+interface IResult<T> {
+  data: T;
+  errMsg: string;
+  statusCode: number;
+}
+
+export interface IServiceResult<T> {
+  success: boolean;
+  data?: T;
+  err?: IError;
+}
+
+
+const openApiRequest = async <T>(url: string, options: any, needToken: boolean = true): Promise<IServiceResult<T>> => {
+  const requestOptions = { ...options };
+  const headers: any = {
+    'Content-Type': 'application/json',
+    'X-Gizwits-Application-Id': getGlobalData('appID'),
+  };
+
+  if (needToken) {
+    headers['X-Gizwits-User-token'] = getGlobalData('token');
+  }
+
+  requestOptions.header = { ...headers, ...options.headers };
+  delete requestOptions.headers;
+  // console.log(`openApi request ${url}`, requestOptions);
+  const openApiUrl = getGlobalData('cloudServiceInfo').openAPIInfo;
+  const res = await request<IResult<T>>('https://' + openApiUrl + url, requestOptions);
+  // 统一封装OPEN API的错误码
+  if (res.statusCode >= 200 && res.statusCode < 300) {
+    return {
+      success: true,
+      data: res.data
+    }
+  }
+
+  let baseError = {
+    success: false,
+    err: {
+      errorCode: errorCode.GIZ_SDK_HTTP_REQUEST_FAILED.errorCode,
+      errorMessage: '',
+    }
+  }
+  try {
+    baseError = {
+      success: false,
+      err: {
+        errorCode: (res.data as any).error_code,
+        errorMessage: (res.data as any).error_message,
+      }
+    }
+  } catch (error) {
+    
+  }
+  return baseError;
+}
+
+const siteApiRequest = async <T>(url: string, options: any): Promise<IServiceResult<T>> => {
+  const requestOptions = { ...options };
+  const headers: any = {
+    'Content-Type': 'application/json',
+  };
+
+  requestOptions.header = { ...headers, ...options.headers };
+  delete requestOptions.headers;
+  // console.log(`openApi request ${url}`, requestOptions);
+  const siteInfo = (getGlobalData('cloudServiceInfo') || {}).siteInfo || 'site.gizwits.com';
+  const res = await request<IResult<T>>('http://' + siteInfo + url, requestOptions);
+  if (res.statusCode >= 200 && res.statusCode < 300) {
+    return {
+      success: true,
+      data: res.data
+    }
+  }
+
+  let baseError = {
+    success: false,
+    err: {
+      errorCode: errorCode.GIZ_SDK_HTTP_REQUEST_FAILED.errorCode,
+      errorMessage: '',
+    }
+  }
+  try {
+    baseError = {
+      success: false,
+      err: {
+        errorCode: (res.data as any).error_code,
+        errorMessage: (res.data as any).error_message,
+      }
+    }
+  } catch (error) {
+    
+  }
+  return baseError;
+}
+
+export { siteApiRequest };
+export default openApiRequest;

package/src/productConfigFileManage.ts

@@ -0,0 +1,44 @@
+import openApiRequest, { siteApiRequest } from './openApiRequest';
+import { IDataPointConfig } from './protocol/DataPoint';
+// 管理配置文件
+
+interface IData {
+  [key: string]: IDataPointConfig;
+}
+class ProductConfigFileManage {
+  data: IData = {};
+  key = 'dataPointConfig';
+
+  init = async () =>  {
+    const data = await wx.getStorageSync(this.key) || '{}';
+    let dataJson = {};
+    try {
+      dataJson = JSON.parse(data);
+    } catch (error) {
+      
+    }
+    this.data =dataJson;
+  }
+
+  public getConfigFile = async (pk: string): Promise<IDataPointConfig | null> => {
+    if (!this.data[pk]) {
+      // 不在缓存里，去云端获取
+      const url = `/app/datapoint?product_key=${pk}`;
+      const data = await openApiRequest<IDataPointConfig>(`${url}`, { method: 'GET' });
+      if (data.success && data.data?.entities) {
+        this.data[pk] = data.data as IDataPointConfig;
+        // 更新缓存
+        wx.setStorageSync(this.key, JSON.stringify(this.data))
+      } else {
+        // 请求失败
+        return null;
+      }
+    }
+    return this.data[pk];
+  }
+}
+
+const productConfigFileManage = new ProductConfigFileManage();
+productConfigFileManage.init();
+
+export default productConfigFileManage;

package/src/protocol/Bind.ts

@@ -0,0 +1,22 @@
+import ProtocolBase from "./ProtocolBase";
+import { arrayToString } from "./tool";
+
+class Bind extends ProtocolBase {
+  passcode: string = '';
+  constructor(data: number[]) {
+    super(data);
+    let index = 0;
+    const passcodeLen = parseInt(arrayToString(this.content.slice(index, index + 2)), 16);
+    index += 2;
+    let passcodeString = '';
+    this.content.slice(index, index + passcodeLen).map(item => {
+      passcodeString += String.fromCharCode(item);
+    });
+    this.passcode = passcodeString;
+  }
+  static pack = () => {
+    return [0,0,0,3,3,0,0,6];
+  }
+}
+
+export default Bind;

package/src/protocol/GetDeviceStatus.ts

@@ -0,0 +1,61 @@
+import productConfigFileManage from "../productConfigFileManage";
+import ProtocolBase from "./ProtocolBase";
+import { fillString, hexStrint2byte, string2Bytes } from "./tool";
+
+class GetDeviceStatus extends ProtocolBase {
+  static pack = async (productKey: string, gwDid?: string, attrNames?: string[], ) => {
+    const configFile = await productConfigFileManage.getConfigFile(productKey);
+    if (configFile) {
+      const isAdaptiveDatapoint = configFile.protocolType === 'var_len';
+      const header = [0,0,0,3];
+      const len = [0];
+      let flag = [0];
+      const cmd = [0,147];
+      let sn = [0,0,0,0];
+      let payload = [2];
+  
+      if (gwDid) {
+        flag = [1];
+        const hexLen = fillString(gwDid.length.toString(16), 4)
+        
+        const didLen = hexStrint2byte(hexLen);
+        const did = string2Bytes(gwDid);
+        sn = sn.concat(didLen).concat(did);
+      }
+  
+      if (isAdaptiveDatapoint) {
+        // 变长action
+        payload = [18];
+        // 根据 attrs 补充flag
+        let flagString = '';
+  
+        if (!attrNames) {
+          // 全部填充
+          configFile.entities[0].attrs.map(() => {
+            flagString = `1${flagString}`;
+          })
+        } else {
+          const attrs = attrNames.reduce((acc, cur) => ({ ...acc, [cur]: 1 }), {});
+          configFile.entities[0].attrs.map((item) => {
+            if (attrs[item.name]) {
+              flagString = `1${flagString}`;
+            } else {
+              flagString = `0${flagString}`;
+            }
+          });
+        }
+  
+        flagString = fillString(flagString, Math.ceil(flagString.length / 8) * 8);
+        payload = payload.concat(hexStrint2byte(parseInt(flagString, 2).toString(16)));
+      }
+  
+      const endData = flag.concat(cmd).concat(sn).concat(payload);
+      len[0] = endData.length;
+      
+      return header.concat(len).concat(endData);
+    }
+    return null;
+  }
+}
+
+export default GetDeviceStatus;

package/src/protocol/Login.ts

@@ -0,0 +1,43 @@
+import ProtocolBase from "./ProtocolBase";
+import { arrayToString, fillString, hexStrint2byte, string2Bytes } from "./tool";
+
+
+interface IPackParame {
+  passcode: string;
+}
+class Login extends ProtocolBase {
+  result: boolean = false;
+  didLength: number = 0;
+  did: string = '';
+  constructor(data: number[]) {
+    super(data);
+
+    let index = 0;
+    this.result = this.content[0] === 0;
+    index ++;
+    if (this.flag[0] === 1) {
+      this.didLength = parseInt(arrayToString(this.content.slice(index, index + 2)), 16);
+
+      index += 2;
+      let didString = '';
+      this.content.slice(index, this.content.length).map(item => {
+        didString += String.fromCharCode(item);
+      });
+      this.did = didString;
+    }
+  }
+  static pack = ({passcode}: IPackParame) => {
+    const header = [0,0,0,3];
+    let len = [0];
+    const flag = [0];
+    const cmd = [0,8];
+    const passcodeLen = hexStrint2byte(fillString(passcode.length.toString(16), 4));
+    const passcodeArr = string2Bytes(passcode);
+
+    const data = flag.concat(cmd).concat(passcodeLen).concat(passcodeArr);
+    len = hexStrint2byte(data.length.toString(16));
+    return header.concat(len).concat(data);
+  }
+}
+
+export default Login;

package/src/protocol/ProtocolBase.ts

@@ -0,0 +1,53 @@
+import { arrayToString, checkHeader, getProtocolLen } from "./tool";
+
+class ProtocolBase {
+  header: string = '';
+  len:number = 0;
+  flag:number[] = [0];
+  cmd :string = '';
+  content:number[] = [];
+  
+  constructor(data?: number[]) {
+    if (data && data.length > 0) {
+      this.formatP0(data);
+    }
+  }
+
+  decodeLen = (arr) => {
+    let multiplier = 1;
+    let value=0;
+    let digit = 0;
+    let index = 0;
+    do {
+      digit = arr[index];
+      value += (digit & 127) * multiplier;
+      multiplier *= 128;
+      index += 1;
+    } while ((digit & 128) != 0);
+    return value;
+  }
+
+  formatP0 = (data) => {
+    let pointer = checkHeader(data);
+    if (pointer === false) {
+      // 包头错误
+      throw new Error("Header Error");
+    }
+
+    this.header = arrayToString(data.slice(0, pointer));
+    
+    const nextData = data.slice(pointer, data.length);
+
+    const lengthIndex = getProtocolLen(nextData);
+
+    this.len = this.decodeLen(nextData.slice(0, lengthIndex));
+    pointer += lengthIndex;
+    this.flag = data.slice(pointer, pointer + 1);
+    pointer += 1;
+    this.cmd = arrayToString(data.slice(pointer, pointer + 2));
+    pointer += 2;
+    this.content = data.slice(pointer, data.length)
+  }
+}
+
+export default ProtocolBase;

package/src/protocol/WifiConfig.ts

@@ -0,0 +1,41 @@
+import ProtocolBase from "./ProtocolBase";
+import { formatCodesFromStr } from "./tool";
+
+class WifiConfig extends ProtocolBase {
+  constructor(data: number[]) {
+    super(data);
+  }
+  static pack = (ssid: string, password: string) => {
+    const header = [0, 0, 0, 3];
+    const length: number[] = [];
+    const flag = [0];
+    const cmd = [0, 1];
+
+    const [ASSID, ssidLength] = formatCodesFromStr(ssid);
+    const [APassword, passwordLength] = formatCodesFromStr(password);
+
+    const content = flag.concat(
+      cmd,
+      ssidLength,
+      ASSID,
+      passwordLength,
+      APassword
+    );
+
+    let contentLength = content.length;
+    while (contentLength > 0) {
+      length.push(contentLength);
+      contentLength -= 255;
+    }
+
+    const config = header.concat(length).concat(content);
+    const buffer = new ArrayBuffer(config.length);
+    const uint8Array = new Uint8Array(buffer);
+    for (let i = 0; i < buffer.byteLength; i++) {
+      uint8Array[i] = config[i];
+    }
+    return uint8Array;
+  }
+}
+
+export default WifiConfig;