mini_program_gizwits_sdk 3.0.2-beta → 3.0.7

package/dist/src/errorCode.d.ts

@@ -0,0 +1,5 @@
+interface IErrorCode {
+    [key: string]: IError;
+}
+declare const errorCode: IErrorCode;
+export default errorCode;

package/dist/src/globalData.d.ts

@@ -0,0 +1,2 @@
+export declare function setGlobalData(key: any, value: any): void;
+export declare function getGlobalData(key: any): any;

package/dist/src/openApiRequest.d.ts

@@ -0,0 +1,9 @@
+export interface IServiceResult<T> {
+    success: boolean;
+    data?: T;
+    err?: IError;
+}
+declare const openApiRequest: <T>(url: string, options: any, needToken?: boolean) => Promise<IServiceResult<T>>;
+declare const siteApiRequest: <T>(url: string, options: any) => Promise<IServiceResult<T>>;
+export { siteApiRequest };
+export default openApiRequest;

package/dist/src/productConfigFileManage.d.ts

@@ -0,0 +1,12 @@
+import { IDataPointConfig } from './protocol/DataPoint';
+interface IData {
+    [key: string]: IDataPointConfig;
+}
+declare class ProductConfigFileManage {
+    data: IData;
+    key: string;
+    init: () => Promise<void>;
+    getConfigFile: (pk: string) => Promise<IDataPointConfig>;
+}
+declare const productConfigFileManage: ProductConfigFileManage;
+export default productConfigFileManage;

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

@@ -0,0 +1,7 @@
+import ProtocolBase from "./ProtocolBase";
+declare class Bind extends ProtocolBase {
+    passcode: string;
+    constructor(data: number[]);
+    static pack: () => number[];
+}
+export default Bind;

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

@@ -0,0 +1,52 @@
+export interface IDataPointConfig {
+    name: string;
+    protocolType: 'var_len' | 'standard';
+    entities: IDataPointEntitie[];
+}
+interface IDataPointEntitie {
+    display_name: string;
+    attrs: IDataPointAttr[];
+}
+interface IDataPointPosition {
+    byte_offset: number;
+    unit: 'bit' | 'byte';
+    len: number;
+    bit_offset: number;
+}
+declare type TDataType = 'bool' | 'uint8' | 'uint16' | 'uint32' | 'binary' | 'enum' | 'number';
+interface IUnitSpec {
+    addition: number;
+    max: number;
+    ratio: number;
+    min: number;
+}
+declare type TDataOptionType = 'status_writable' | 'status_readonly' | 'alert' | 'fault' | 'ALL';
+export interface IDataPointAttr {
+    display_name: string;
+    uint_spec: IUnitSpec;
+    name: string;
+    data_type: TDataType;
+    position: IDataPointPosition;
+    type: TDataOptionType;
+    id: number;
+    enum: string[];
+    desc: string;
+}
+interface IRawData {
+    header: string;
+    len: string;
+    flag: string;
+    cmd: string;
+    sn: string;
+    action: string;
+    payload: string;
+}
+declare type messageType = 'APP2DEV' | 'DEV2APP' | 'UNKNOW';
+declare const unpack: (data: number[], pk: string) => Promise<{
+    kvData: {};
+    rawData: IRawData;
+    message: string;
+    messageType: messageType;
+}>;
+declare const pack: (data: object, pk: string) => Promise<number[]>;
+export { pack, unpack };

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

@@ -0,0 +1,5 @@
+import ProtocolBase from "./ProtocolBase";
+declare class GetDeviceStatus extends ProtocolBase {
+    static pack: (productKey: string, gwDid?: string, attrNames?: string[]) => Promise<number[]>;
+}
+export default GetDeviceStatus;

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

@@ -0,0 +1,12 @@
+import ProtocolBase from "./ProtocolBase";
+interface IPackParame {
+    passcode: string;
+}
+declare class Login extends ProtocolBase {
+    result: boolean;
+    didLength: number;
+    did: string;
+    constructor(data: number[]);
+    static pack: ({ passcode }: IPackParame) => number[];
+}
+export default Login;

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

@@ -0,0 +1,11 @@
+declare class ProtocolBase {
+    header: string;
+    len: number;
+    flag: number[];
+    cmd: string;
+    content: number[];
+    constructor(data?: number[]);
+    decodeLen: (arr: any) => number;
+    formatP0: (data: any) => void;
+}
+export default ProtocolBase;

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

@@ -0,0 +1,6 @@
+import ProtocolBase from "./ProtocolBase";
+declare class WifiConfig extends ProtocolBase {
+    constructor(data: number[]);
+    static pack: (ssid: string, password: string) => Uint8Array;
+}
+export default WifiConfig;

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

@@ -0,0 +1,9 @@
+declare const checkHeader: (data: any) => number | false;
+declare const getProtocolLen: (data: any) => number;
+declare function arrayToString(arr: number[]): string;
+declare const fillString: (string: string, num: number, foot?: boolean) => string;
+declare const string2Bytes: (str: string) => number[];
+declare const hexStrint2byte: (str: string) => number[];
+declare const formatCode: (str: any) => number[];
+declare const formatCodesFromStr: (str: string) => number[][];
+export { checkHeader, getProtocolLen, arrayToString, fillString, string2Bytes, hexStrint2byte, formatCodesFromStr, formatCode };

package/dist/src/randomCode.d.ts

@@ -0,0 +1,7 @@
+interface IGetRandomCodes {
+    SSID: string;
+    password: string;
+    pks: string[];
+}
+declare const getRandomCodes: ({ SSID, password, pks }: IGetRandomCodes) => string[];
+export default getRandomCodes;

package/dist/src/request.d.ts

@@ -0,0 +1 @@
+export default function request<T>(url: string, options: any): Promise<T>;

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

@@ -0,0 +1,53 @@
+import { IServiceResult } from '../openApiRequest';
+import { IRandomCodesResult } from '../sdk';
+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';
+}
+export declare const getBindingList: () => Promise<IServiceResult<IDevice[]>>;
+export interface IBindMacParams {
+    mac: string;
+    productKey: string;
+    productSecret: string;
+    alias?: string;
+    beOwner?: boolean;
+}
+export declare function bindMac({ mac, productKey, productSecret, alias, beOwner, }: IBindMacParams): Promise<IServiceResult<IOpenApiDevice>>;
+export interface IUnbindReturn {
+    failed: string[];
+    success: string[];
+}
+export declare function unbindDevice({ devices, }: {
+    devices: IDevice[];
+}): Promise<IServiceResult<IUnbindReturn>>;
+interface ICheckDeviceRegisterParams {
+    SSID: string;
+    password: string;
+    productKeys: string[];
+}
+export declare function checkDeviceRegister({ SSID, password, productKeys, }: ICheckDeviceRegisterParams): Promise<IServiceResult<IRandomCodesResult[]>>;
+interface ISafeRegisterParams {
+    productKey: string;
+    productSecret: string;
+    mac: string;
+    passcode: string;
+    gwDid?: string;
+    isReset: boolean;
+}
+export interface ISafeRegisterReturn {
+    successDevices: IDevice[];
+    failedDevices: IDevice[];
+}
+export declare function safeRegister({ productKey, productSecret, mac, passcode, gwDid, isReset, }: ISafeRegisterParams): Promise<IServiceResult<ISafeRegisterReturn>>;
+export {};

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

@@ -0,0 +1,8 @@
+export interface ILoginRes {
+    expire_at: number;
+    token: string;
+    uid: string;
+}
+export declare function AnonymousLogin({ uid }: {
+    uid: string;
+}): Promise<import("../openApiRequest").IServiceResult<ILoginRes>>;

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

@@ -0,0 +1,4 @@
+export declare const psKeySign: (productSecret: string) => {
+    Signature: string;
+    timestamp: number;
+};

package/dist/src/sleep.d.ts

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

package/dist/src/socket.d.ts

@@ -0,0 +1,107 @@
+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;
+    _connections: {
+        [wsInfo: string]: Connection;
+    };
+    _onDeviceStatusChanged?: IOnDeviceStatusChanged;
+    constructor({ appID, token, uid, limitSocketNum, }: IGWSProps);
+    init(): Promise<IError>;
+    _getDevice: (did: string) => IDevice | IError;
+    _getConnect: (device: IDevice) => Connection;
+    _getDeviceAndConnect: (did: string) => IError | [IDevice, Connection];
+    connectDevice: (device: IDevice) => {
+        success: boolean;
+        errorCode: IError;
+    } | {
+        success: boolean;
+        errorCode?: undefined;
+    };
+    connect: (did: string) => IError;
+    send: (did: string, raw: Uint8Array[]) => IError | Promise<WechatMiniprogram.GeneralCallbackResult>;
+    writeData: (device: IDevice, attrs: ICommonObj) => {
+        success: boolean;
+    };
+    write: (did: string, attrs: ICommonObj) => IError | Promise<WechatMiniprogram.GeneralCallbackResult>;
+    readStatus: (device: IDevice, names?: string[]) => {
+        success: boolean;
+    };
+    read: (did: string, names?: string[]) => IError | Promise<WechatMiniprogram.GeneralCallbackResult>;
+    close: () => void;
+    subscribeDeviceStatus: (cb: IOnDeviceStatusChanged) => void;
+    _handleDeviceStatusChanged: IOnDeviceStatusChanged;
+    _getBindingList: (limit?: number, skip?: number, cacheList?: IDevice[]) => Promise<IDevice[] | IRespError>;
+    _getWebsocketConnInfo: (device: any) => "wss://wxstage.gizwits.com" | "wss://wxm2m.gizwits.com";
+}
+interface IConnectProps extends ICommonProps {
+    wsInfo: string;
+    onDeviceStatusChanged?: IOnDeviceStatusChanged;
+}
+export declare class Connection {
+    ready: boolean;
+    appID: string;
+    token: string;
+    uid: string;
+    commType: string;
+    _heartbeatInterval: number;
+    _keepaliveTime: number;
+    _loginIntveral: number;
+    autoSubscribe: boolean;
+    _wsUrl: string;
+    _websocket: WechatMiniprogram.SocketTask | null;
+    _heartbeatTimerId?: any;
+    _loginFailedTimes: number;
+    _subDids: Set<string>;
+    _socketRespHandleMap: {
+        [cmd: string]: (resp?: any) => void;
+    };
+    _onDeviceStatusChanged?: IOnDeviceStatusChanged;
+    constructor({ appID, token, uid, wsInfo, onDeviceStatusChanged, }: IConnectProps);
+    _addSubDid: (did: any) => void;
+    _connectWS: () => void;
+    _subDevices: (dids: string[]) => void;
+    _send: (data: object, forced?: boolean) => Promise<WechatMiniprogram.GeneralCallbackResult>;
+    close: () => void;
+    handleClose: (res: {
+        code: number;
+        reason: string;
+    }) => void;
+    handleOpen: () => void;
+    handleMessage: ({ data }: {
+        data: string | ArrayBuffer;
+    }) => void;
+    handleError: (err: {
+        errMsg: string;
+    }) => void;
+    _login: () => void;
+    _tryLoginAgain: () => void;
+    _startPing: () => void;
+    _stopPing: () => void;
+    pongResp: () => void;
+    _loginResp: (data: any) => void;
+    _subscribeResp: (data: any) => void;
+    _onlineResp: (data: {
+        did: string;
+        online: boolean;
+    }) => void;
+    _rawChangedResp: (data: IDeviceRawStatusChangedProps) => void;
+    _statusChangedResp: (data: IDeviceStatusChangedProps) => void;
+    _invalidMsgResp: (data: any) => void;
+}
+export {};

package/dist/src/utils.d.ts

@@ -0,0 +1,29 @@
+import { IProductInfo } from './sdk';
+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;
+export declare const wrapErrorInfo: (errorMessage: string) => {
+    errorCode: string;
+    errorMessage: string;
+};
+export declare const unionBy: <T>(array: T[], key: string) => T[];
+interface IWXDevicesResult {
+    success: true;
+    bleDevices: WechatMiniprogram.BlueToothDevice[];
+}
+export declare function isWXDevicesResult(res: unknown): res is IWXDevicesResult;
+export declare function str2Buf(arr: string): ArrayBuffer;
+export declare const numberArray2Uint8Array: (numArr: number[]) => Uint8Array;
+export declare const advertisData2PkAndMac: (advertisData: ArrayBuffer, pks: string[]) => {
+    productKey: any;
+    mac: any;
+};
+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: 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;
+export {};

package/dist/src/wechatApi.d.ts

@@ -0,0 +1,33 @@
+interface IBluetoothAdapterStateResult {
+    discovering: boolean;
+    available: boolean;
+}
+interface IWechatResult {
+    errMsg: string;
+    errCode: number;
+}
+export declare function openBluetoothAdapter(): Promise<IWechatResult>;
+export declare function closeBluetoothAdapter(): Promise<IWechatResult>;
+export declare function getBluetoothAdapterState(): Promise<IBluetoothAdapterStateResult>;
+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 {
+    uuid: string;
+    isPrimary: boolean;
+}
+export declare function getBLEDeviceServices(deviceId: string): Promise<IBLEService[]>;
+interface IBLECharacteristic {
+    uuid: string;
+    properties: {
+        read: boolean;
+        write: boolean;
+        notify: boolean;
+        indicate: boolean;
+    };
+}
+export declare function getBLEDeviceCharacteristics(deviceId: string, serviceId: string): Promise<IBLECharacteristic[]>;
+export declare function notifyBLECharacteristicValueChange(deviceId: string, serviceId: string, characteristicId: string, state?: boolean): Promise<IWechatResult>;
+export declare function writeBLECharacteristicValue(deviceId: string, serviceId: string, characteristicId: string, value: ArrayBuffer): Promise<IWechatResult>;
+export declare function unpackWriteBLECharacteristicValue(deviceId: string, serviceId: string, characteristicId: string, value: ArrayBuffer): Promise<IWechatResult>;
+export {};

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

@@ -0,0 +1,26 @@
+import { IRandomCodesResult, IResult } from "../sdk";
+interface IRejectCallback {
+    (result: IResult<unknown>): void;
+}
+declare class ConfigBase {
+    ssid: string;
+    password: string;
+    specialProductKeys: string[];
+    disableSearchDevice: boolean;
+    specialProductKeySecrets: string[];
+    private timeoutHandler;
+    private setDeviceOnboardingDeployRej?;
+    constructor(ssid: string, password: string, specialProductKeys: string[], specialProductKeySecrets: string[]);
+    cleanTimeout: () => void;
+    stopDeviceOnboardingDeploy: () => void;
+    hasTimeoutHandler: (cb?: IRejectCallback) => boolean;
+    handleTimeout: () => void;
+    protected searchDevice: ({ ssid, password }: {
+        ssid: string;
+        password: string;
+    }) => Promise<IResult<IRandomCodesResult[]>>;
+    initDeviceOnboardingDeploy: (_res: any, rej: any) => void;
+    protected startTimeoutTimer: (timeout: number) => void;
+    protected bindDevices: (devices: IDevice[]) => Promise<IResult<IDevice[]>>;
+}
+export default ConfigBase;

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

@@ -0,0 +1,21 @@
+import { IRandomCodesResult, IResult } from "../sdk";
+import ConfigBase from "./ConfigBase";
+interface configDeviceParams {
+    ssid: string;
+    password: string;
+    softAPSSIDPrefix: string;
+}
+interface ISetDeviceOnboardingDeployProps {
+    timeout: number;
+    isBind: boolean;
+    softAPSSIDPrefix: string;
+}
+declare class ApConfig extends ConfigBase {
+    disableSendUDP: boolean;
+    private sendMessageInterval;
+    private UDPSocketHandler;
+    destroy: () => void;
+    configDevice: ({ ssid, password, softAPSSIDPrefix }: configDeviceParams) => Promise<IResult<IRandomCodesResult[]>>;
+    setDeviceOnboardingDeploy: ({ timeout, isBind, softAPSSIDPrefix, }: ISetDeviceOnboardingDeployProps) => Promise<IResult<IDevice[]>>;
+}
+export default ApConfig;

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

@@ -0,0 +1,40 @@
+import { IRandomCodesResult, IResult } from "../sdk";
+import ConfigBase from "./ConfigBase";
+interface IArgs {
+    bleDeviceId: string;
+    arrayBuffer: ArrayBuffer;
+    serviceUUIDSuffix?: string;
+    characteristicUUIDSuffix?: string;
+}
+export declare function sendBLEConfigCmd({ bleDeviceId, arrayBuffer, serviceUUIDSuffix, characteristicUUIDSuffix, }: IArgs): Promise<boolean | void>;
+interface configBLEDeviceParams {
+    ssid: string;
+    password: string;
+    softAPSSIDPrefix?: string;
+    timeout: number;
+}
+interface ISetDeviceOnboardingDeployProps {
+    timeout: number;
+    isBind: boolean;
+    softAPSSIDPrefix: string;
+}
+declare class BLEConfig extends ConfigBase {
+    destroy: () => void;
+    isValidBleDevice: (bleDevice: WechatMiniprogram.BlueToothDevice, softAPSSIDPrefix?: string) => boolean;
+    enableBluetoothDevicesDescovery: () => Promise<{
+        success: false;
+        err: IError;
+    } | {
+        success: true;
+    }>;
+    enableAndGetBluetoothDevices: (softAPSSIDPrefix?: string) => Promise<{
+        success: false;
+        err: IError;
+    } | {
+        success: true;
+        bleDevices?: WechatMiniprogram.BlueToothDevice[];
+    }>;
+    setDeviceOnboardingDeploy: ({ timeout, isBind, softAPSSIDPrefix, }: ISetDeviceOnboardingDeployProps) => Promise<IResult<IDevice[]>>;
+    configBLEDevice: ({ ssid, password, softAPSSIDPrefix, }: configBLEDeviceParams) => Promise<IResult<IRandomCodesResult[]>>;
+}
+export default BLEConfig;

package/global.d.ts

@@ -0,0 +1,28 @@
+
+
+declare namespace md5 {
+  function hex(data: any): any;
+}
+
+declare function md5(data: any): any;
+
+type TUtf8 = {
+  toBytes: (data: any) => any
+}
+
+type TUtils = {
+  utf8: TUtf8;
+}
+
+interface ecb {
+  new(data: any): any;
+}
+
+type TModeOfOperation = {
+  ecb: ecb;
+}
+
+declare namespace aesjs {
+  const utils: TUtils;
+  const ModeOfOperation: TModeOfOperation;
+}

package/index.ts

@@ -0,0 +1,7 @@
+import 'miniprogram-api-typings';
+import gizwitsSdk from './src/sdk';
+import errorCode from './src/errorCode';
+import { BleHandle } from './src/ble';
+
+export { errorCode, BleHandle };
+export default gizwitsSdk;

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "mini_program_gizwits_sdk",
-  "version": "3.0.2-beta",
-  "description": "兼容微信蓝牙权限变更",
+  "version": "3.0.7",
+  "description": "兼容模组重置，蓝牙卡死的情况",
   "main": "./dist/index.js",
   "scripts": {
     "test": "node_modules/mocha/bin/_mocha -r ts-node/register tests/**/*.spec.ts -file ./tests/setup-wx.js -timeout 60s",
     "testMy": "node_modules/mocha/bin/_mocha -r ts-node/register tests/utils/productConfigFileManage.spec.ts -file ./tests/setup-wx.js -timeout 60s",
     "testBle": "node_modules/mocha/bin/_mocha -r ts-node/register tests/bleConfig/sdk.ble.spec.ts -file ./tests/setup-wx.js -timeout 60s",
-    "build": "webpack",
+    "build": "rm -r ./dist && webpack",
+    "release": "npm run build && release-it",
     "cover": "istanbul cover node_modules/mocha/bin/_mocha -- -r ts-node/register tests/**/*.spec.ts -file ./tests/setup-wx.js -timeout 60s",
     "coveralls": "npm run cover -- --report lcovonly && cat ./coverage/lcov.info | coveralls"
   },
@@ -37,6 +38,8 @@
     "typescript": "^3.8.3",
     "uglifyjs-webpack-plugin": "^2.2.0",
     "webpack": "^4.42.1",
+    "@release-it/conventional-changelog": "^2.0.0",
+    "release-it": "^14.2.2",
     "webpack-bundle-analyzer": "^4.5.0",
     "webpack-cli": "^3.3.11"
   },