mini_program_gizwits_sdk 3.0.2-beta → 3.0.7

package/src/services/devices.ts

@@ -0,0 +1,210 @@
+import openApiRequest, { IServiceResult } from '../openApiRequest';
+import getRandomCodes from '../randomCode';
+import { IRandomCodesResult } from '../sdk';
+import { psKeySign } from './tool';
+// eslint-disable-next-line import/no-commonjs
+// const CryptoJS = require('crypto-js');
+import {  enc, AES, mode, pad } from 'crypto-js';
+
+export interface IOpenApiDevice {
+  product_key: string;
+  did: string;
+  mac: string;
+  passcode: string;
+  is_online: boolean;
+  host: string;
+  port: string;
+  port_s: string;
+  ws_port: number;
+  wss_port: number;
+  dev_alias: string;
+  remark: string;
+  type: 'normal' | 'center_control' | 'sub_dev';
+}
+
+interface IDeviceRes {
+  devices: IOpenApiDevice[];
+}
+
+export const getBindingList = async (): Promise<IServiceResult<IDevice[]>> => {
+  const data = await openApiRequest<IDeviceRes>(
+    '/app/bindings?show_disabled=0&limit=1000&skip=0',
+    {
+      method: 'GET',
+    }
+  );
+
+  if (data.success) {
+    const newDevices: IDevice[] = data.data!.devices.map((item) => {
+      return {
+        productKey: item.product_key,
+        mac: item.mac,
+        did: item.did,
+        host: item.host,
+        port_s: item.port_s,
+        port: item.port,
+        ws_port: item.ws_port,
+        wss_port: item.wss_port,
+        isBleOnline: false,
+        isLanOnline: false,
+        connectType: 'NONE',
+        name: item.dev_alias,
+        isBind: true,
+        isOnline: item.is_online,
+      };
+    });
+    return {
+      success: true,
+      data: newDevices,
+    };
+  }
+  return {
+    success: false,
+    err: data.err,
+  };
+};
+
+export interface IBindMacParams {
+  mac: string;
+  productKey: string;
+  productSecret: string;
+  alias?: string;
+  beOwner?: boolean;
+}
+export async function bindMac({
+  mac,
+  productKey,
+  productSecret,
+  alias,
+  beOwner,
+}: IBindMacParams): Promise<IServiceResult<IOpenApiDevice>> {
+  const dataJson = {
+    mac,
+    product_key: productKey,
+    dev_alias: alias,
+    set_owner: beOwner,
+  };
+
+  const { Signature, timestamp } = psKeySign(productSecret);
+
+  const data = await openApiRequest<IOpenApiDevice>('/app/bind_mac', {
+    method: 'POST',
+    data: dataJson,
+    headers: {
+      'X-Gizwits-Signature': Signature,
+      'X-Gizwits-Timestamp': timestamp,
+    },
+  });
+  return data;
+}
+
+export interface IUnbindReturn {
+  failed: string[];
+  success: string[];
+}
+export async function unbindDevice({
+  devices,
+}: {
+  devices: IDevice[];
+}): Promise<IServiceResult<IUnbindReturn>> {
+  const data = await openApiRequest<IUnbindReturn>('/app/bindings', {
+    method: 'DELETE',
+    data: {
+      devices: devices.map((device) => {
+        return { did: device.did };
+      }),
+    },
+  });
+  return data;
+}
+
+interface ICheckDeviceRegisterParams {
+  SSID: string;
+  password: string;
+  productKeys: string[];
+}
+export async function checkDeviceRegister({
+  SSID,
+  password,
+  productKeys,
+}: ICheckDeviceRegisterParams): Promise<IServiceResult<IRandomCodesResult[]>> {
+  const codes = getRandomCodes({
+    SSID,
+    password,
+    pks: productKeys,
+  });
+  let codeStr = '';
+  codes.map((item) => {
+    codeStr += `${item},`;
+  });
+  codeStr = codeStr.substring(0, codeStr.length - 1);
+  const data = await openApiRequest<IRandomCodesResult[]>(
+    `/app/device_register?random_codes=${codeStr}`,
+    { method: 'get' }
+  );
+  return data;
+}
+
+interface ISafeRegisterParams {
+  productKey: string;
+  productSecret: string;
+  mac: string;
+  passcode: string;
+  gwDid?: string;
+  isReset: boolean;
+}
+
+export interface ISafeRegisterReturn {
+  successDevices: IDevice[];
+  failedDevices: IDevice[];
+}
+export async function safeRegister({
+  productKey,
+  productSecret,
+  mac,
+  passcode,
+  gwDid,
+  isReset,
+}: ISafeRegisterParams): Promise<IServiceResult<ISafeRegisterReturn>> {
+  let dataStr = `is_reset=${isReset ? 1 : 0}&mac=${mac}&passcode=${passcode}`;
+  if (gwDid) {
+    dataStr += `&gw_did=${gwDid}`;
+  }
+
+  const key = enc.Hex.parse(productSecret);
+  const iv = enc.Hex.parse('');
+  const srcs = enc.Utf8.parse(dataStr);
+  const encrypted = AES.encrypt(srcs, key, {
+    iv: iv,
+    mode: mode.ECB,
+    padding: pad.Pkcs7,
+  });
+  const hexStr = encrypted.ciphertext.toString().toUpperCase();
+  const data = await openApiRequest<string>(
+    `/dev/${productKey}/device`,
+    {
+      method: 'POST',
+      data: {
+        data: hexStr,
+      },
+      headers: {
+        'content-type': 'application/x-www-form-urlencoded',
+      },
+    },
+    false
+  );
+  if (data.success) {
+    // 解码
+    return {
+      success: true,
+      data: {
+        successDevices: [],
+        failedDevices: [],
+      },
+    };
+  }
+  return {
+    success: false,
+    err: data.err,
+  };
+}

package/src/services/login.ts

@@ -0,0 +1,15 @@
+import openApiRequest from "../openApiRequest";
+
+export interface ILoginRes {
+  expire_at: number;
+  token: string;
+  uid: string;
+}
+export async function AnonymousLogin ({uid}: {uid: string}) {
+  return openApiRequest<ILoginRes>('/app/users', {
+    data: {
+      phone_id: uid,
+    },
+    method: 'POST',
+  }, false)
+}

package/src/services/tool.ts

@@ -0,0 +1,10 @@
+// eslint-disable-next-line import/no-commonjs
+import { MD5 } from "crypto-js";
+
+export const psKeySign = (productSecret: string) => {
+  const timestamp = Math.round(new Date().getTime()/1000);
+
+  const str = productSecret + timestamp;
+  const Signature = MD5(str).toString();
+  return {Signature, timestamp};
+}

package/src/sleep.ts

@@ -0,0 +1,2 @@
+const sleep = (time: number) => new Promise<void>(resolve => setTimeout(() => resolve(), time));
+export default sleep;

package/src/socket.ts

@@ -0,0 +1,449 @@
+import errorCode from "./errorCode";
+import request from "./openApiRequest";
+import { compareWXSDKVersion, isError } from './utils';
+
+// commType = 'custom' | 'attrs_v4'
+// socketType = 'socket' | 'ssl_socket'
+
+
+interface IRespError {
+  err?: IError;
+}
+
+interface ICommonProps {
+  appID: string;
+  token: string;
+  uid: string;
+}
+
+interface IGWSProps extends ICommonProps {
+  limitSocketNum?: boolean;
+}
+
+export default class GizwitsWS {
+
+  appID: string;
+  token: string;
+  uid: string;
+  _maxSocketNum: number;
+  _bindingDevices: { [did: string]: IDevice } | null = null;
+  _connections: { [wsInfo: string]: Connection } = {};
+  _onDeviceStatusChanged?: IOnDeviceStatusChanged;
+
+  /**
+   * @param limitSocketNum 是否限制 socket 连接数，如果限制则按照小程序sdk限制最大连接数，否则如果超过小程序限制连接数，微信可能会关闭之前的连接，也可以会有异常。
+   */
+  constructor({
+    appID,
+    token,
+    uid,
+    limitSocketNum = true,
+  }: IGWSProps) {
+    this.appID = appID;
+    this.token = token;
+    this.uid = uid;
+    const wxSDKVersion = wx.getSystemInfoSync().SDKVersion
+    this._maxSocketNum = limitSocketNum
+      ? compareWXSDKVersion(wxSDKVersion, '1.7.0') === -1 ? 1 : 5
+      : 0;
+  }
+
+  async init() {
+    try {
+      const result = await this._getBindingList();
+      if ((result as IRespError).err?.errorCode) {
+        return { errorCode: (result as IRespError).err?.errorCode, errorMessage: 'getting binding list failed' };
+      } else {
+        this._bindingDevices = (result as IDevice[]).reduce((map, device) => ({ ...map, [device.did]: device }), {});
+        return null;
+      }
+    } catch (error) {
+      return errorCode.GIZ_SDK_OTHERWISE
+    }
+  }
+
+  _getDevice = (did: string): IDevice | IError => {
+    if (this._bindingDevices === null) {
+      return errorCode.GIZ_SDK_SDK_NOT_INITIALIZED
+    }
+
+    const device = this._bindingDevices[did];
+    if (device == null) {
+      return errorCode.GIZ_OPENAPI_DEVICE_NOT_BOUND;
+    }
+    return device;
+  }
+
+  _getConnect = (device: IDevice): Connection => {
+    const wsInfo = this._getWebsocketConnInfo(device);
+    return this._connections[wsInfo];
+  }
+
+  _getDeviceAndConnect = (did: string): [IDevice, Connection] | IError => {
+    const device = this._getDevice(did)
+    if (isError(device)) {
+      return device;
+    }
+    const conn = this._getConnect(device);
+    if (conn == null) {
+      return errorCode.GIZ_SDK_DEVICE_NOT_SUBSCRIBED;
+    }
+    return [device, conn]
+  }
+
+  connectDevice = (device: IDevice) => {
+    const wsInfo = this._getWebsocketConnInfo(device);
+    let conn = this._connections[wsInfo];
+    if (conn == null) {
+      const connNum = Object.keys(this._connections).length;
+      if (this._maxSocketNum !== 0 && connNum >= this._maxSocketNum) {
+        return { success: false, errorCode: errorCode.MAX_CONNECT };
+      }
+      conn = new Connection({
+        appID: this.appID,
+        token: this.token,
+        uid: this.uid,
+        wsInfo,
+        onDeviceStatusChanged: this._handleDeviceStatusChanged
+      });
+      this._connections[wsInfo] = conn;
+    }
+    conn._addSubDid(device.did);
+    if (conn._websocket == null) {
+      conn._connectWS();
+    } else if (conn.ready) {
+      conn._subDevices([device.did]);
+    }
+    return { success: true };
+  }
+
+  connect = (did: string) => {
+    const device = this._getDevice(did)
+    if (isError(device)) {
+      return device;
+    }
+    const res = this.connectDevice(device);
+    return res.success ? null : res.errorCode;
+  }
+
+  send = (did: string, raw: Uint8Array[]) => {
+    const res = this._getDeviceAndConnect(did);
+    if (isError(res)) {
+      return res;
+    }
+    return res[1]._send({
+      cmd: "c2s_raw",
+      data: {
+        did: did,
+        raw
+      }
+    });
+  }
+
+  writeData = (device: IDevice, attrs: ICommonObj) => {
+    const conn = this._getConnect(device);
+    const success = conn != null;
+    if (success) {
+      conn._send({
+        cmd: "c2s_write",
+        data: {
+          did: device.did,
+          attrs
+        }
+      });
+    }
+    return { success };
+  }
+
+  write = (did: string, attrs: ICommonObj) => {
+    const res = this._getDeviceAndConnect(did);
+    if (isError(res)) {
+      return res;
+    }
+    return res[1]._send({
+      cmd: "c2s_write",
+      data: {
+        did: did,
+        attrs: attrs
+      }
+    });
+  }
+
+  readStatus = (device: IDevice, names?: string[]) => {
+    const conn = this._getConnect(device);
+    const success = conn != null;
+    if (success) {
+      conn._send({
+        cmd: "c2s_read",
+        data: {
+          did: device.did,
+          names,
+        }
+      });
+    }
+    return { success };
+  }
+
+  read = (did: string, names?: string[]) => {
+    const res = this._getDeviceAndConnect(did);
+    if (isError(res)) {
+      return res;
+    }
+    return res[1]._send({
+      cmd: "c2s_read",
+      data: {
+        did: did,
+        names: names
+      }
+    });
+  }
+
+  close = () => {
+    Object.values(this._connections).forEach(conn => conn.close());
+  }
+
+  subscribeDeviceStatus = (cb: IOnDeviceStatusChanged) => {
+    this._onDeviceStatusChanged = cb;
+  }
+
+  _handleDeviceStatusChanged: IOnDeviceStatusChanged = (data) => {
+    const device = this._getDevice(data.did);
+    if (!isError(device)) {
+      this._onDeviceStatusChanged && this._onDeviceStatusChanged(data);
+    }
+  }
+
+  _getBindingList = async (limit: number = 20, skip: number = 0, cacheList: IDevice[] = []): Promise<IDevice[] | IRespError> => {
+    const url = `/app/bindings?show_disabled=0&limit=${limit}&skip=${skip}`;
+    const { err, data } = await request<{ devices: IDevice[] }>(`${url}`, { method: 'GET' });
+    if (err) {
+      return {err};
+    }
+    const devices = [...cacheList, ...data?.devices || []]
+    if (data && data.devices.length === limit) {
+      return await this._getBindingList(limit, limit + skip, devices);
+    }
+    return devices;
+  }
+
+  _getWebsocketConnInfo = (device) => {
+    return device.host.includes('stage')
+      ? 'wss://wxstage.gizwits.com'
+      : 'wss://wxm2m.gizwits.com';
+  }
+
+
+}
+
+interface IConnectProps extends ICommonProps {
+  wsInfo: string;
+  onDeviceStatusChanged?: IOnDeviceStatusChanged;
+}
+
+export class Connection {
+  ready: boolean = false;
+  appID: string;
+  token: string;
+  uid: string;
+  commType: string = 'attrs_v4';
+  _heartbeatInterval = 60;
+  _keepaliveTime = 180;
+  _loginIntveral = 5000;
+  autoSubscribe = false;
+  _wsUrl: string;
+  _websocket: WechatMiniprogram.SocketTask | null = null;
+  _heartbeatTimerId?: any;
+  _loginFailedTimes: number = 0;
+  _subDids: Set<string> = new Set();
+  _socketRespHandleMap: { [cmd: string]: (resp?: any) => void } = {};
+  _onDeviceStatusChanged?: IOnDeviceStatusChanged;
+
+  constructor({
+    appID,
+    token,
+    uid,
+    wsInfo,
+    onDeviceStatusChanged,
+  }: IConnectProps) {
+    this.appID = appID;
+    this.token = token;
+    this.uid = uid;
+    this._wsUrl = `${wsInfo}/ws/app/v1`;
+    this._heartbeatTimerId = undefined;
+    this._loginFailedTimes = 0;
+    this._onDeviceStatusChanged = onDeviceStatusChanged;
+    this._socketRespHandleMap = {
+      pong: this.pongResp,
+      login_res: this._loginResp,
+      subscribe_res: this._subscribeResp,
+      s2c_online_status: this._onlineResp,
+      s2c_raw: this._rawChangedResp,
+      s2c_noti: this._statusChangedResp,
+      s2c_invalid_msg: this._invalidMsgResp,
+    }
+  }
+
+  _addSubDid = (did) => {
+    this._subDids.add(did);
+  }
+
+  _connectWS = () => {
+    this._websocket = wx.connectSocket({ url: this._wsUrl });
+    this._websocket.onClose(this.handleClose);
+    this._websocket.onOpen(this.handleOpen);
+    this._websocket.onError(this.handleError);
+    this._websocket.onMessage(this.handleMessage);
+  }
+
+  _subDevices = (dids: string[]) => {
+    const json = {
+      cmd: "subscribe_req",
+      data: dids.map(did => ({ did }))
+    };
+    this._send(json);
+  }
+
+  _send = (data: object, forced: boolean = false) => {
+    console.log('Socket send', data, forced);
+    return new Promise<WechatMiniprogram.GeneralCallbackResult>((resolve) => {
+      if (this._websocket && (forced || this.ready)) {
+        this._websocket.send({
+          data: JSON.stringify(data),
+          complete: (res) => {
+            console.debug('GIZ_SDK: socket send res', res);
+            if ([
+              'sendSocketMessage:fail debug invoke no active session',
+              'sendSocketMessage:fail wcwss taskID not exist'
+            ].includes(res && res.errMsg)) {
+              // 重新connect
+              this._websocket && this._websocket.close({});
+              this._connectWS();
+            }
+            resolve(res);
+          }
+        })
+      }
+    })
+  }
+
+  close = () => {
+    this.ready = false;
+    if (this._heartbeatTimerId) {
+      clearInterval(this._heartbeatTimerId);
+    }
+    if (this._websocket) {
+      this._websocket.close({});
+      this._websocket = null;
+    }
+  }
+
+  handleClose = (res: { code: number, reason: string }) => {
+    console.log('socket close', res);
+    this.close();
+    this._stopPing();
+  }
+
+  handleOpen = () => {
+    // socket 打开后执行登录
+    console.log(' socket open')
+    this._login();
+  }
+
+  handleMessage = ({ data }: { data: string | ArrayBuffer }) => {
+    console.log('message', data);
+    const res = JSON.parse(data as string);
+    const handle = this._socketRespHandleMap[res.cmd];
+    handle && handle(res.data);
+  }
+
+  handleError = (err: { errMsg: string }) => {
+    console.debug('GIZ_SDK: socket error', err);
+  }
+
+  _login = () => {
+    const data = {
+      cmd: 'login_req',
+      data: {
+        appid: this.appID,
+        uid: this.uid,
+        token: this.token,
+        p0_type: this.commType,
+        heartbeat_interval: this._keepaliveTime,
+        auto_subscribe: this.autoSubscribe
+      }
+    }
+    this._send(data, true);
+  }
+
+  _tryLoginAgain = () => {
+    this._loginFailedTimes += 1;
+    setTimeout(() => {
+      this._login();
+    }, this._loginFailedTimes * this._loginIntveral);
+  }
+
+  _startPing = () => {
+    this._heartbeatTimerId = setInterval(() => {
+      this._send({ cmd: 'ping' });
+    }, this._heartbeatInterval * 1000);
+  }
+
+  _stopPing = () => {
+    this._heartbeatTimerId && clearInterval(this._heartbeatTimerId);
+  }
+
+  pongResp = () => {
+    // 不处理
+  }
+
+  _loginResp = (data) => {
+    if (data.success == true) {
+      this._loginFailedTimes = 0;
+      this.ready = true;
+      this._startPing();
+      this._subDevices([...this._subDids]);
+    } else if (this._loginFailedTimes < 3) {
+      console.debug('GIZ_SDK: Login failed, will try again, please wait...');
+      this._tryLoginAgain();
+    } else {
+      console.debug('GIZ_SDK: Login failed');
+      this.close();
+    }
+  }
+
+  _subscribeResp = (data) => {
+    console.log('GIZ_SDK: subscribe_res', data);
+    if (data && data.success) {
+      // 订阅成功设备获取设备状态
+      data.success.forEach(d => this._send({
+        cmd: "c2s_read",
+        data: {
+          did: d.did,
+        }
+      }))
+    }
+    console.debug('GIZ_SDK: subscribe_res', data);
+  }
+
+  _onlineResp = (data: { did: string, online: boolean }) => {
+    this._onDeviceStatusChanged && this._onDeviceStatusChanged({
+      did: data.did, attrs: { is_online: data.online, ...data }
+    });
+  }
+
+  _rawChangedResp = (data: IDeviceRawStatusChangedProps) => {
+    this._onDeviceStatusChanged && this._onDeviceStatusChanged(data);
+  }
+
+  _statusChangedResp = (data: IDeviceStatusChangedProps) => {
+    this._onDeviceStatusChanged && this._onDeviceStatusChanged(data);
+  }
+
+  _invalidMsgResp = (data) => {
+    if (data.error_code === 1003) {
+      // 重新登录
+      this._login();
+    }
+    console.debug('GIZ_SDK: s2c_invalid_msg', data);
+  }
+}