mini_program_gizwits_sdk 3.1.12-2 → 3.1.13-1

package/index.ts

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mini_program_gizwits_sdk",
-  "version": "3.1.12-2",
-  "description": "切换到es6打包，修正微信Promise不执行的问题",
+  "version": "3.1.13-1",
+  "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",
@@ -31,7 +31,7 @@
     "chai": "^4.2.0",
     "coveralls": "^3.0.11",
     "istanbul": "^1.1.0-alpha.1",
-    "miniprogram-api-typings": "^3.3.0",
+    "miniprogram-api-typings": "^3.5.0",
     "mocha": "^7.1.1",
     "release-it": "^14.2.2",
     "sinon": "^9.2.4",

package/src/handler/EventListener.ts

@@ -0,0 +1,44 @@
+export default class EventListener<T> {
+  public listenerMap: any = {};
+  public addEventListener = async <K extends keyof T>(
+    type: K,
+    func: T[K]
+  ) => {
+    if (!this.listenerMap[type]) {
+      // 创建一个新的
+      this.listenerMap[type] = [];
+    }
+
+    if (this.listenerMap[type].indexOf(func) === -1) {
+      this.listenerMap[type].push(func);
+    }
+    return {
+      success: true,
+    };
+  }
+
+  /**
+   * 移除事件监听
+   * @param type 事件监听名称，详见下表
+   * @param func 事件监听回调
+   * @returns
+   */
+   public removeEventListener = <K extends keyof T>(
+    type: K,
+    func: T[K]
+  ) => {
+    if (this.listenerMap[type]) {
+      const index = this.listenerMap[type].indexOf(func);
+      if (index !== -1) {
+        // 删除数组中的这一行
+        this.listenerMap[type].splice(index, 1);
+        return {
+          success: true,
+        };
+      }
+    }
+    return {
+      success: false,
+    };
+  };
+}

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

@@ -7,16 +7,17 @@ import {
   parseBroadcastData,
   unionBy,
   wrapErrorInfo,
-} from './utils';
-import { unpackWriteBLECharacteristicValue } from './wechatApi';
-import Bind from './protocol/Bind';
-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';
+} from '../utils';
+import { unpackWriteBLECharacteristicValue } from '../wechatApi';
+import Bind from '../protocol/Bind';
+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';
 
 type GizBleDeviceListotifications = (devices: IDevice[]) => void;
 type GizBleDeviceDataNotifications = (
@@ -66,7 +67,7 @@ interface ConstructorParams {
   offlineThreshold?: number;
 }
 
-export class BleHandle {
+export class BleHandle extends EventListener<TBleHandleEvent> {
   private serviceUUIDSuffix: string;
   // private characteristicUUIDSuffix: string;
   public connectedList: ConnectDevice[] = [];
@@ -84,7 +85,6 @@ export class BleHandle {
 
   private isActive = true; // 小程序是否活跃
 
-  private listenerMap: any = {};
   // private globalListenerMap = {};
   public scanList: IDevice[] = [];
   constructor({
@@ -95,6 +95,7 @@ export class BleHandle {
     },
     offlineThreshold,
   }: ConstructorParams) {
+    super();
     const { serviceUUIDSuffix } = bleHandleParams;
     this.serviceUUIDSuffix = serviceUUIDSuffix;
     this.pks = pks;
@@ -610,48 +611,6 @@ export class BleHandle {
     });
   };
 
-  public addEventListener = async <K extends keyof TBleHandleEvent>(
-    type: K,
-    func: TBleHandleEvent[K]
-  ) => {
-    if (!this.listenerMap[type]) {
-      // 创建一个新的
-      this.listenerMap[type] = [];
-    }
-
-    if (this.listenerMap[type].indexOf(func) === -1) {
-      this.listenerMap[type].push(func);
-    }
-    return {
-      success: true,
-    };
-  }
-
-  /**
-   * 移除事件监听
-   * @param type 事件监听名称，详见下表
-   * @param func 事件监听回调
-   * @returns
-   */
-   public removeEventListener = <K extends keyof TBleHandleEvent>(
-    type: K,
-    func: TBleHandleEvent[K]
-  ) => {
-    if (this.listenerMap[type]) {
-      const index = this.listenerMap[type].indexOf(func);
-      if (index !== -1) {
-        // 删除数组中的这一行
-        this.listenerMap[type].splice(index, 1);
-        return {
-          success: true,
-        };
-      }
-    }
-    return {
-      success: false,
-    };
-  };
-
   public watchBleDevice = async (
     deviceId,
     func

package/src/handler/lan.ts

@@ -0,0 +1,368 @@
+import GizLog from "../GizLog";
+import Bind from "../protocol/Bind";
+import DiscoverUDP from "../protocol/DiscoverUdp";
+import Login from "../protocol/Login";
+import ProtocolBase from "../protocol/ProtocolBase";
+import { arrayToString, arrayToUint8 } from "../protocol/tool";
+import { IResult } from "../sdk";
+import sleep from "../sleep";
+import { ab2numbers } from "../utils";
+import EventListener from "./EventListener";
+
+// 局域网连接设备结构
+interface ConnectDevice {
+  mac: string
+  productKey: string
+  socketHandle: TCPHandler
+}
+
+// 局域网设备
+interface ILanDevice extends IDevice {
+  expandData: DiscoverUDP
+  ip: string
+}
+
+type GizLanDeviceDataNotifications = (devices: IDevice[]) => void;
+export interface TLanHandleEvent {
+  GizLanDeviceList: GizLanDeviceDataNotifications;
+}
+
+
+export class LanHandle extends EventListener<TLanHandleEvent> {
+  // private characteristicUUIDSuffix: string;
+  public connectedList: ConnectDevice[] = [];
+  private pks: string[] = [];
+  // private globalListenerMap = {};
+  public scanList: ILanDevice[] = [];
+
+  private boradcastTimer: any;
+
+  private UDPSocket: WechatMiniprogram.UDPSocket;
+
+  private deviceUDPPort = 12414
+  private appUDPPort = 2415
+  private offlineThreshold = 20000 // 超过20s 没有信号，则认为离线
+  private isActive = true //当前是否是前台
+
+  private listenDevOfflineTimer: any = null; 
+
+
+  constructor({pks}) {
+    super();
+    this.pks = pks;
+  }
+
+  init = () => {
+    this.UDPSocket = wx.createUDPSocket();
+    this.UDPSocket.bind();
+    this.UDPSocket.onMessage(this.onMessage);
+    this.UDPSocket.onError(this.onError);
+    GizLog.info('Start UDP Discover')
+    this.startDiscover();
+    this.listenDevOffline(this.offlineThreshold);
+    wx.onAppShow(this.onAppShow);
+    wx.onAppHide(this.onAppHide);
+  }
+
+  private onAppShow = () => {
+    // 更新所有蓝牙设备的Ctime
+    this.isActive = true;
+    this.scanList.map(item => {
+      item.ctime = Date.now();
+    })
+  }
+
+  private onAppHide = () => {
+    this.isActive = false;
+  }
+
+  private listenDevOffline = (offlineThreshold: number) => {
+    // 定时检查设备列表，移除超时设备
+    this.listenDevOfflineTimer = setInterval(() => {
+      // 非激活状态不处理
+      if (!this.isActive) return;
+      const now = new Date().getTime();
+      const newDeviceList = this.scanList.filter((d) => {
+        return now - d.ctime < offlineThreshold;
+      });
+      if (newDeviceList.length !== this.scanList.length) {
+        GizLog.debug('remove lan device')
+        this.scanList = newDeviceList;
+        this.notifyDevices();
+      }
+    }, 500);
+  };
+
+  private notifyDevices = () => {
+    if (this.listenerMap['GizLanDeviceList']) {
+      this.listenerMap['GizLanDeviceList'].map((item) => {
+        item(this.scanList);
+      });
+    }
+  }
+
+  isSameDevice = (deviceA: IDevice, deviceB: IDevice) => {
+    return deviceA.mac === deviceB.mac && deviceA.productKey === deviceB.productKey
+  }
+
+  // 解除订阅
+  disConnectDevice = (target: IDevice) => {
+    const index = this.connectedList.findIndex(item => item.productKey === target.productKey && item.mac === target.mac);
+    try {
+      if (index !== -1) {
+        // 删除这个设备
+        this.connectedList[index].socketHandle.destory();
+        this.connectedList.splice(index, 1);
+      }
+      return {success: true}
+
+    } catch (error) {
+      return {success: false, err: error}
+    }
+  }
+
+  connectDevice = async (device) => {
+    const target = this.scanList.find(item => this.isSameDevice(device, item));
+    // 检查是否有连接
+    if (!target) {
+      return {
+        success: false,
+      }
+    }
+
+    const connectDevice = this.connectedList.find(item => this.isSameDevice(device, (item as unknown as IDevice)))
+    if (connectDevice) {
+      return {
+        success: true
+      }
+    } else {
+      const tcpHandler = new TCPHandler({ip: target.ip, mac: target.mac, productKey: target.productKey, onClose: this.onDeviceClose})
+      const res = await tcpHandler.connect()
+      if (res.success) {
+        this.connectedList.push({
+          mac: target.mac,
+          productKey: target.productKey,
+          socketHandle: tcpHandler,
+        })
+      } else {
+        tcpHandler.destory();
+      }
+      return res;
+    }
+
+  }
+
+  onError = (err) => {
+    GizLog.warn('Discover Error', err)
+  }
+
+  onMessage = (res: WechatMiniprogram.UDPSocketOnMessageCallbackResult) => {
+    const numberArrary = ab2numbers(res.message)
+    const discoverPackage = new DiscoverUDP(numberArrary)
+    if (discoverPackage.mac !== '' && this.pks.includes(discoverPackage.productKey)) {
+      // 合法设备
+      this.updateDevice(discoverPackage, res.remoteInfo.address)
+    }
+  }
+
+  // tcp 设备断开连接
+  onDeviceClose = ({productKey, mac}) => {
+    const index = this.connectedList.findIndex(item => item.productKey === productKey && item.mac === mac);
+    if (index !== -1) {
+      // 删除这个设备
+      this.connectedList.splice(index, 1);
+    }
+  }
+
+  // 数据点控制
+  public write = async (device: IDevice, value: ArrayBuffer) => {
+    const index = this.connectedList.findIndex(item => this.isSameDevice(item as unknown as IDevice, device));
+    if (index !== -1) {
+      const socketHandle = this.connectedList[index].socketHandle;
+      socketHandle.write(value)
+    }
+    return {
+      success: false,
+      message: 'device not sub',
+    };
+  };
+
+  updateDevice = (updateDevice: DiscoverUDP, ip: string) => {
+    const target = this.scanList.find(item => item.mac === updateDevice.mac);
+    if (!target) {
+      const device: ILanDevice = {
+        mac: updateDevice.mac,
+        ip,
+        productKey: updateDevice.productKey,
+        did: updateDevice.did,
+        expandData: updateDevice,
+        name: "",
+        isBind: false,
+        connectType: "NONE",
+        isOnline: false,
+        isLanOnline: true,
+        isBleOnline: false,
+        ctime: Date.now()
+      };
+      this.scanList.push(device);
+      this.notifyDevices();
+    } else {
+      // 存在设备 更新字段
+      target.ctime = Date.now()
+    }
+  }
+
+  sendBoradCast = () => {
+    // 发送发现包
+    if(this.UDPSocket) {
+      this.UDPSocket.send({
+        address: '255.255.255.255',
+        message: DiscoverUDP.pack(),
+        port: this.deviceUDPPort
+      })
+      GizLog.debug('Send UDP Discover')
+    }
+  }
+
+  private startDiscover = () => {
+    this.sendBoradCast()
+    this.boradcastTimer = setInterval(() => {
+      this.sendBoradCast()
+    }, 5000)
+  }
+
+  public destory = () => {
+    this.boradcastTimer && clearInterval(this.boradcastTimer);
+    this.UDPSocket && this.UDPSocket.close();
+    this.listenDevOfflineTimer && clearInterval(this.listenDevOfflineTimer);
+    wx.offAppShow(this.onAppShow);
+    wx.offAppHide(this.onAppHide);
+  }
+}
+
+
+interface ITCPHandlerProps {
+  ip: string
+  mac: string
+  productKey: string
+  onClose: (ip) => void
+}
+class TCPHandler {
+  private deviceTCPPort = 12416
+  private ip = ""
+  private productKey = ""
+  private mac = ""
+  private tcpHandler: WechatMiniprogram.TCPSocket = null;
+
+  private onCloseListener = ({mac, productKey}) => {}
+
+  constructor({ip, onClose, mac, productKey}: ITCPHandlerProps) {
+    this.ip = ip;
+    this.mac = mac;
+    this.productKey = productKey;
+    this.onCloseListener = onClose;
+  }
+
+  connect = async () => {
+    // 创建
+    return new Promise<IResult<any>>(async (res) => {
+      const onConnect = () => {
+        // 发送绑定
+        const config = Bind.pack()
+        this.tcpHandler.write(arrayToUint8(config))
+        GizLog.debug('connect success try login')
+      }
+      const onError = (err) => {
+        res({
+          success: true,
+          err: err
+        })
+      }
+      const onMessage = (message: WechatMiniprogram.TCPSocketOnMessageCallbackResult) => {
+        // 接收绑定回复
+        // 然后再发起登录
+        const baseProtocol = new ProtocolBase(ab2numbers(message.message))
+        switch (baseProtocol.cmd) {
+          case '0007': {
+            // 绑定命令字的回复
+            const bindRes = new Bind(ab2numbers(message.message));
+            const loginPack = Login.pack({passcode: bindRes.passcode})
+            this.tcpHandler.write(arrayToUint8(loginPack))
+            break;
+          }
+          case '0009': {
+            const loginRes = new Login(ab2numbers(message.message))
+            if (loginRes.result) {
+              // 登录成功
+              res({
+                success: true
+              })
+              // 创建监听
+              this.initListener()
+            } else {
+              // 设备通知登录失败
+              res({
+                success: false,
+              })
+            }
+          }
+        }
+      }
+
+      try {
+        this.tcpHandler = wx.createTCPSocket();
+        
+        // 设置监听
+        this.tcpHandler.onConnect(onConnect)
+        this.tcpHandler.onError(onError)
+        this.tcpHandler.onMessage(onMessage)
+
+        this.tcpHandler.connect({
+          address: this.ip,
+          port: this.deviceTCPPort,
+          timeout: 2
+        })
+        await sleep(4000)
+        res({
+          success: false,
+          err: null
+        })
+      } catch(err) {
+        GizLog.error("connect lan error", err);
+      } finally {
+        this.tcpHandler.offConnect(onConnect)
+        this.tcpHandler.offError(onError)
+        this.tcpHandler.offMessage(onMessage)
+      }
+    })
+
+  }
+
+  write = (data: ArrayBuffer) => {
+    this.tcpHandler.write(data);
+  }
+
+  onMessage = (message) => {
+    const baseProtocol = new ProtocolBase(ab2numbers(message.message))
+    GizLog.debug("on tcp message", baseProtocol)
+  }
+
+  onError = () => {}
+
+  onClose = () => {
+    this.onCloseListener({productKey: this.productKey, mac: this.mac})
+  }
+
+  initListener = () => {
+    this.tcpHandler.onError(this.onError)
+    this.tcpHandler.onMessage(this.onMessage)
+    this.tcpHandler.onClose(this.onClose)
+  }
+
+  destory = () => {
+    this.tcpHandler && this.tcpHandler.close();
+    this.tcpHandler.offError(this.onError)
+    this.tcpHandler.offMessage(this.onMessage)
+    this.tcpHandler.offClose(this.onClose)
+  }
+}

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

@@ -1,8 +1,8 @@
-import errorCode from "./errorCode";
-import GizLog from "./GizLog";
-import request from "./openApiRequest";
-import sleep from "./sleep";
-import { compareWXSDKVersion, isError } from './utils';
+import errorCode from "../errorCode";
+import GizLog from "../GizLog";
+import request from "../openApiRequest";
+import sleep from "../sleep";
+import { compareWXSDKVersion, isError } from '../utils';
 
 // commType = 'custom' | 'attrs_v4'
 // socketType = 'socket' | 'ssl_socket'
@@ -146,7 +146,7 @@ export default class GizwitsWS {
     return res.success ? null : res.errorCode;
   }
 
-  send = (did: string, raw: Uint8Array[]) => {
+  send = (did: string, raw: number[]) => {
     const res = this._getDeviceAndConnect(did);
     if (isError(res)) {
       return res;

package/src/protocol/DiscoverUDP.ts

@@ -0,0 +1,80 @@
+import GizLog from "../GizLog";
+import ProtocolBase from "./ProtocolBase";
+import { arrayToString } from "./tool";
+
+type TDecodeType = 'ASCII' | 'HEX'
+type TDeviceType = 'ASCII' | 'HEX'
+
+class DiscoverUDP extends ProtocolBase {
+
+  did = '';
+  mac = '';
+  productKey = '';
+  deviceType = 0;
+  apiUrl = "";
+  protocolVersion = ""
+  mcuVersion = ""
+  moduleVersion = ""
+
+  constructor(data: number[]) {
+    super(data);
+    let index = 0;
+    try {
+      index = this.baseParse(index, 'did')
+      index = this.baseParse(index, 'mac', 'HEX')
+      index = this.baseParse(index, 'moduleVersion')
+      index = this.baseParse(index, 'productKey')
+      index += 8
+      index = this.parseEndChat(index, 'apiUrl')
+      index = this.parseEndChat(index, 'protocolVersion')
+      this.mcuVersion = ""
+      this.content.slice(index, this.content.length).map(item => {
+        this.mcuVersion += String.fromCharCode(item);
+      })
+    } catch (error) {
+      GizLog.warn('Parse DiscoverUDP error', error)
+    }
+  }
+
+  parseEndChat = (index, key) => {
+    let string = ''
+    const data = this.content.slice(index, this.content.length);
+    for (let i in data) {
+      const item = data[i];
+      index += 1;
+      if (item === 0){
+        break;
+      }
+      string += String.fromCharCode(item);
+    }
+    this[key] = string
+    return index;
+  }
+
+  baseParse = (index, key, type:TDecodeType = 'ASCII') => {
+    const len = parseInt(arrayToString(this.content.slice(index, index + 2)), 16);
+    index += 2;
+    let stringData = '';
+    this.content.slice(index, index + len).map(item => {
+      if (type === 'ASCII') {
+        stringData += String.fromCharCode(item);
+      } else {
+        stringData += item.toString(16);
+      }
+    });
+    this[key] = stringData;
+    return index + len;
+  }
+
+  static pack = () => {
+    const config = [0,0,0,3,3,0,0,3];
+    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 DiscoverUDP;

package/src/protocol/ProtocolBase.ts

@@ -29,6 +29,7 @@ class ProtocolBase {
 
   formatP0 = (data) => {
     let pointer = checkHeader(data);
+    
     if (pointer === false) {
       // 包头错误
       throw new Error("Header Error");

package/src/protocol/tool.ts

@@ -88,4 +88,13 @@ const formatCodesFromStr = (str: string) => {
   return [codes, len];
 };
 
-export { checkHeader, getProtocolLen, arrayToString, fillString, string2Bytes, hexStrint2byte, formatCodesFromStr, formatCode };
+const arrayToUint8 = (config: number[]) => {
+  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 { checkHeader, getProtocolLen, arrayToString, fillString, string2Bytes, hexStrint2byte, formatCodesFromStr, formatCode, arrayToUint8 };

package/src/sdk.ts

@@ -1,10 +1,10 @@
 import { setGlobalData, getGlobalData } from './globalData';
-import { BleHandle } from './ble';
-import GizwitsWS from './socket';
+import { BleHandle } from './handler/ble';
+import GizwitsWS from './handler/socket';
 
 import ApConfig from './wifiConfig/ap';
 import BLEConfig from './wifiConfig/ble';
-import GizwitsMiniLog, { TLogType } from './GizLog';
+import GizLog, { TLogType } from './GizLog';
 import { errorCode } from '..';
 import { AnonymousLogin, ILoginRes } from './services/login';
 import {
@@ -26,10 +26,8 @@ import {
 } from './utils';
 import productConfigFileManage from './productConfigFileManage';
 import { IDataPointConfig, pack, unpack } from './protocol/DataPoint';
-import { fillString, hexStrint2byte } from './protocol/tool';
-import { getBluetoothAdapterState } from './wechatApi';
-import sentry from './sentry';
-import GizLog from './GizLog';
+import { hexStrint2byte } from './protocol/tool';
+import { LanHandle } from './handler/lan';
 
 // 接口返回格式
 interface ISDKResult<T> {
@@ -159,12 +157,12 @@ class GizwitsMiniSDK {
   // ble device
 
   // udp device
-  private _udpDevices: IDevice[] = [];
-  private get udpDevices() {
-    return this._udpDevices;
+  private _lanDevices: IDevice[] = [];
+  private get lanDevices() {
+    return this._lanDevices;
   }
-  private set udpDevices(data: IDevice[]) {
-    this._udpDevices = data;
+  private set lanDevices(data: IDevice[]) {
+    this._lanDevices = data;
     this.notiDeviceList();
   }
   // udp device
@@ -174,7 +172,7 @@ class GizwitsMiniSDK {
       [...this.deviceList],
       this.bleDevices
     );
-    newDevices = merageLanLocalDevices(newDevices, this.udpDevices);
+    newDevices = merageLanLocalDevices(newDevices, this.lanDevices);
     /**
      * 只能有一种通讯方式
      * 依次LAN BLE WAN
@@ -203,6 +201,15 @@ class GizwitsMiniSDK {
       }
     });
 
+    const lanConnected = this.lanHandle.connectedList;
+    lanConnected.map(item => {
+      const index = newDevices.findIndex(
+        (device) => device.mac === item.mac && device.productKey === item.productKey
+      );
+      if (index !== -1) {
+        newDevices[index].connectType = 'LAN';
+      }
+    })
     return newDevices;
   }
 
@@ -226,6 +233,8 @@ class GizwitsMiniSDK {
   private currentWifiConfigHandle: any;
 
   private _bleHandle: BleHandle;
+  private _lanHandle: LanHandle;
+  
   // private autoScanInterval: IntervalHandle = null;
 
   private _gizSocket: GizwitsWS;
@@ -241,7 +250,6 @@ class GizwitsMiniSDK {
     offlineThreshold,
   }: GizwitsSdkOption) {
     this.productInfo = productInfo;
-
     // 保存相关信息
     setGlobalData('appID', appID);
     setGlobalData('appSecret', appSecret);
@@ -258,6 +266,11 @@ class GizwitsMiniSDK {
 
     GizLog.debug(`init sdk success, current version: ${this.version}`);
 
+    /**
+     * lan 比较特殊
+     * 初始化sdk的时候就要开始扫描设备
+     */
+    this.initLan();
   }
 
   private get bleHandle() {
@@ -271,6 +284,15 @@ class GizwitsMiniSDK {
     return this._bleHandle;
   }
 
+  private get lanHandle() {
+    if (!this._lanHandle) {
+      this._lanHandle = new LanHandle({
+        pks: this.specialProductKeys,
+      });
+    }
+    return this._lanHandle;
+  }
+
   private get socketHandle() {
     if (!this._gizSocket) {
       this._gizSocket = new GizwitsWS({
@@ -306,6 +328,10 @@ class GizwitsMiniSDK {
     this.bleDevices = devices;
   };
 
+  handleLanDevices = (devices: IDevice[]) => {
+    this.lanDevices = devices;
+  }
+
   private handleBleDeviceData = async (
     curDevice: WechatMiniprogram.OnBLECharacteristicValueChangeCallbackResult,
     hexString: string
@@ -368,6 +394,11 @@ class GizwitsMiniSDK {
     });
   };
 
+  private initLan = () => {
+    this.lanHandle.init();
+    this.lanHandle.addEventListener('GizLanDeviceList', this.handleLanDevices);
+  }
+
   /**
    * @description 开启后台自动扫描
    */
@@ -503,6 +534,49 @@ class GizwitsMiniSDK {
         case 'WAN': {
           return this.socketHandle.writeData(target, attrs);
         }
+        case 'LAN': {
+          return this.lanHandle.write(target, numberArray2Uint8Array(value).buffer);
+        }
+      }
+    }
+    return {
+      success: false,
+    };
+  };
+
+  // 发送原始数据
+  writeRaw = async (device: IDevice, data: number[]) => {
+    const target = this.allDevices.find((item) => isSameDevice(item, device));
+    if (!target) {
+      return { success: false, message: 'target is undefind' };
+    }
+    if (target.connectType !== 'NONE') {
+      switch (target.connectType) {
+        case 'BLE_BROADCAST':
+          // 广播的方式发数据 Action+Flags+DataPoints
+          return await this.bleHandle.writeBoradcast(
+            target.bleDeviceID,
+            data
+          );
+        case 'BLE': {
+          if (data) {
+            return await this.bleHandle.write(
+              target.bleDeviceID,
+              numberArray2Uint8Array(data).buffer
+            );
+          } else {
+            // 解码失败
+            return {
+              success: false,
+            };
+          }
+        }
+        case 'WAN': {
+          return this.socketHandle.send(target.did, data);
+        }
+        case 'LAN': {
+          return this.lanHandle.write(target, numberArray2Uint8Array(data).buffer);
+        }
       }
     }
     return {
@@ -577,7 +651,12 @@ class GizwitsMiniSDK {
     connectType?: TConnectType,
     _autoGetDeviceStatus: boolean = true
   ) => {
+    console.log('this.allDevices', this.allDevices)
     let target = this.allDevices.find((item) => isSameDevice(item, device));
+    if (!target) {
+      GizLog.warn('Device Target Not Found')
+      return { success: false };
+    }
 
     // 广播模式不需要连接，所以默认是连接状态
     if (target.connectType === 'BLE_BROADCAST') {
@@ -588,20 +667,14 @@ class GizwitsMiniSDK {
     }
 
     const type: TConnectType = getFirstConnectType(target, connectType);
-    GizLog.log('subscribe', target, connectType);
     if (target.connectType !== 'NONE' && target.connectType !== type) {
       // 已经存在 并且不等于即将订阅的类型
       // 先解除订阅
       await this.unSubscribe(target);
     }
-
     switch (type) {
       case 'BLE': {
         // 连接BLE
-
-        if (!target) {
-          return { success: false };
-        }
         const data = await this.bleHandle.connectDevice(target.bleDeviceID);
         if (data.success) {
           // 蓝牙设备比较特殊，在get 里面从bleHandle里找到连接的设备，再把connectType 设置成BLE，所以这里更新metaData 要强制更新并推送
@@ -617,15 +690,19 @@ class GizwitsMiniSDK {
         // const target = this.deviceList.find((item) =>
         //   isSameDevice(item, device)
         // );
-        if (!target) {
-          return { success: false };
-        }
         const data = this.socketHandle.connectDevice(target);
         if (data.success) {
           this.setDeviceMeta(device, 'connectType', 'WAN', true);
         }
         return data;
       }
+      case 'LAN': {
+        const data = await this.lanHandle.connectDevice(target);
+        if (data.success) {
+          this.setDeviceMeta(device, 'connectType', 'LAN', true);
+        }
+        return data;
+      }
     }
     return {
       success: false,
@@ -658,6 +735,13 @@ class GizwitsMiniSDK {
         }
         return res;
       }
+      case 'LAN': {
+        const res = this.lanHandle.disConnectDevice(target);
+        if (res.success) {
+          this.setDeviceMeta(target, 'connectType', 'NONE', true);
+        }
+        return res;
+      }
     }
     return {
       success: false,
@@ -864,7 +948,7 @@ class GizwitsMiniSDK {
    * setLogLevel
    */
   setLogLevel = (level: TLogType) => {
-    return GizwitsMiniLog.setLogLevel(level);
+    return GizLog.setLogLevel(level);
   }
 
   /**
@@ -912,6 +996,7 @@ class GizwitsMiniSDK {
 
   public destory = () => {
     this.bleHandle.destory();
+    this.lanHandle.destory();
     this.socketHandle.destory();
     this.keepScanTimer && clearInterval(this.keepScanTimer);
   };

package/src/utils.ts

@@ -1,5 +1,5 @@
 import { IProductInfo } from './sdk';
-import { GizwitsWxBlueToothDevice } from './ble';
+import { GizwitsWxBlueToothDevice } from './handler/ble';
 import GizLog from './GizLog';
 
 export function ab2hex(buffer: ArrayBuffer) {