react-native-gizwits-sdk-v5 1.6.2 → 1.6.3

package/src/index.tsx

@@ -0,0 +1,433 @@
+import { NativeEventEmitter, NativeModules } from 'react-native'
+
+import Base from './Base'
+import RNGizDeviceManagerModule, {
+  RNGizDeviceManagerModule as RNGizDeviceManagerModuleClass,
+} from './device'
+import {
+  DeviceDataCallback,
+  DeviceDataRes,
+  DeviceListCallback,
+  DeviceBindCallback,
+  DeviceStateCallback,
+  DeviceBindRes,
+  DeviceStateRes,
+  GizCallback,
+  GizConfigStruct,
+  IDevice,
+} from './types'
+import * as Types from './types'
+import RNGizUserManagerModule, {
+  RNGizUserManagerModule as RNGizUserManagerModuleClass,
+} from './user'
+
+const eventEmitter = new NativeEventEmitter(NativeModules.RNGizSDKManagerModule)
+
+class RNGizSDKManagerModuleClass extends Base {
+  deviceDataCallbacks: DeviceDataCallback[] = []
+  deviceListCallbacks: DeviceListCallback[] = []
+  deviceStateCallbacks: DeviceStateCallback[] = []
+  deviceBindCallbacks: DeviceBindCallback[] = []
+
+  constructor() {
+    super()
+  }
+
+  public registerListener = () => {
+    eventEmitter.addListener('DeviceDataListener', this.deviceDataCallback)
+    eventEmitter.addListener('DeviceListListener', this.deviceListCallback)
+    eventEmitter.addListener('DeviceStateListener', this.deviceStateCallback)
+    eventEmitter.addListener('DeviceBindStateListener', this.deviceBindCallback)
+  }
+  appendDeviceFunction = (device: IDevice) => {
+    // 补充对应的设备方法
+    device.startMusicalRhythm = (
+      sensitivity: number,
+      mode: Types.MusicalRhythmParseMode,
+      callback?: Types.GizMusicalRhythmCallback
+    ) => {
+      return RNGizDeviceManagerModule.startMusicalRhythm(
+        device.id,
+        sensitivity,
+        mode,
+        callback
+      )
+    }
+    device.stopMusicalRhythm = () => {
+      return RNGizDeviceManagerModule.stopMusicalRhythm(device.id)
+    }
+    device.bleCapability.connect = () => {
+      return RNGizDeviceManagerModule.connect(device.id, 'BLE')
+    }
+    device.lanCapability.connect = () => {
+      return RNGizDeviceManagerModule.connect(device.id, 'LAN')
+    }
+    device.mqttCapability.connect = () => {
+      return RNGizDeviceManagerModule.connect(device.id, 'MQTT')
+    }
+    device.bleCapability.disConnect = () => {
+      return RNGizDeviceManagerModule.disConnect(device.id, 'BLE')
+    }
+    device.lanCapability.disConnect = () => {
+      return RNGizDeviceManagerModule.disConnect(device.id, 'LAN')
+    }
+    device.mqttCapability.disConnect = () => {
+      return RNGizDeviceManagerModule.disConnect(device.id, 'MQTT')
+    }
+
+    device.bleCapability.sendDp = (data: Object) => {
+      return RNGizDeviceManagerModule.sendDp(device.id, 'BLE', data)
+    }
+    device.lanCapability.sendDp = (data: Object) => {
+      return RNGizDeviceManagerModule.sendDp(device.id, 'LAN', data)
+    }
+    device.mqttCapability.sendDp = (data: Object) => {
+      return RNGizDeviceManagerModule.sendDp(device.id, 'MQTT', data)
+    }
+
+    device.bleCapability.getDp = (attrs?: string[]) => {
+      return RNGizDeviceManagerModule.getDp(device.id, 'BLE', attrs)
+    }
+    device.lanCapability.getDp = (attrs?: string[]) => {
+      return RNGizDeviceManagerModule.getDp(device.id, 'LAN', attrs)
+    }
+    device.mqttCapability.getDp = (attrs?: string[]) => {
+      return RNGizDeviceManagerModule.getDp(device.id, 'MQTT', attrs)
+    }
+
+    device.bleCapability.getDeviceInfo = () => {
+      return RNGizDeviceManagerModule.getDeviceInfo(device.id, 'BLE')
+    }
+    device.lanCapability.getDeviceInfo = () => {
+      return RNGizDeviceManagerModule.getDeviceInfo(device.id, 'LAN')
+    }
+    device.mqttCapability.getDeviceInfo = () => {
+      return RNGizDeviceManagerModule.getDeviceInfo(device.id, 'MQTT')
+    }
+
+    device.bleCapability.startUpgrade = (
+      firmwareType: Types.GizOTAFirmwareType,
+      callback: Types.GizOtaProgressCallback
+    ) => {
+      return RNGizDeviceManagerModule.startUpgrade(
+        device.id,
+        'BLE',
+        firmwareType,
+        callback
+      )
+    }
+    device.lanCapability.startUpgrade = (
+      firmwareType: Types.GizOTAFirmwareType,
+      callback: Types.GizOtaProgressCallback
+    ) => {
+      return RNGizDeviceManagerModule.startUpgrade(
+        device.id,
+        'LAN',
+        firmwareType,
+        callback
+      )
+    }
+    device.mqttCapability.startUpgrade = (
+      firmwareType: Types.GizOTAFirmwareType,
+      callback: Types.GizOtaProgressCallback
+    ) => {
+      return RNGizDeviceManagerModule.startUpgrade(
+        device.id,
+        'MQTT',
+        firmwareType,
+        callback
+      )
+    }
+
+    /**
+     * 配网相关
+     */
+    device.bleCapability.provideWiFiCredentials = (
+      ssid: string,
+      password: string,
+      timeout: number,
+      callback: Types.GizProvideWiFiCredentialsCallback,
+      bindWithUid?: boolean
+    ) => {
+      return RNGizDeviceManagerModule.provideWiFiCredentials(
+        device.id,
+        'BLE',
+        ssid,
+        password,
+        timeout,
+        callback,
+        bindWithUid ?? false
+      )
+    }
+    device.lanCapability.provideWiFiCredentials = (
+      ssid: string,
+      password: string,
+      timeout: number,
+      callback: Types.GizProvideWiFiCredentialsCallback
+    ) => {
+      return RNGizDeviceManagerModule.provideWiFiCredentials(
+        device.id,
+        'LAN',
+        ssid,
+        password,
+        timeout,
+        callback,
+        false
+      )
+    }
+    device.mqttCapability.provideWiFiCredentials = (
+      ssid: string,
+      password: string,
+      timeout: number,
+      callback: Types.GizProvideWiFiCredentialsCallback
+    ) => {
+      return RNGizDeviceManagerModule.provideWiFiCredentials(
+        device.id,
+        'MQTT',
+        ssid,
+        password,
+        timeout,
+        callback,
+        false
+      )
+    }
+    device.bleCapability.stopProvideWiFiCredentials = () => {
+      return RNGizDeviceManagerModule.stopProvideWiFiCredentials(
+        device.id,
+        'BLE'
+      )
+    }
+    device.lanCapability.stopProvideWiFiCredentials = () => {
+      return RNGizDeviceManagerModule.stopProvideWiFiCredentials(
+        device.id,
+        'LAN'
+      )
+    }
+    device.mqttCapability.stopProvideWiFiCredentials = () => {
+      return RNGizDeviceManagerModule.stopProvideWiFiCredentials(
+        device.id,
+        'MQTT'
+      )
+    }
+
+    /**
+     * 配网相关
+     */
+
+    device.updateDeviceInfo = (alias?: string, remark?: string) => {
+      return RNGizDeviceManagerModule.updateDeviceInfo(device.id, alias, remark)
+    }
+    device.bind = (alias?: string, remark?: string) => {
+      return RNGizDeviceManagerModule.bind(device.id, alias, remark)
+    }
+    device.unBind = () => {
+      return RNGizDeviceManagerModule.unBind(device.id)
+    }
+    device.register = () => {
+      return RNGizDeviceManagerModule.register(device.id)
+    }
+
+    device.bleCapability.checkUpdate = (
+      firmwareType: Types.GizOTAFirmwareType
+    ) => {
+      return RNGizDeviceManagerModule.checkUpdate(
+        device.id,
+        'BLE',
+        firmwareType
+      )
+    }
+    device.lanCapability.checkUpdate = (
+      firmwareType: Types.GizOTAFirmwareType
+    ) => {
+      return RNGizDeviceManagerModule.checkUpdate(
+        device.id,
+        'LAN',
+        firmwareType
+      )
+    }
+    device.mqttCapability.checkUpdate = (
+      firmwareType: Types.GizOTAFirmwareType
+    ) => {
+      return RNGizDeviceManagerModule.checkUpdate(
+        device.id,
+        'MQTT',
+        firmwareType
+      )
+    }
+
+    device.bleCapability.provideWiFiCredentials = (
+      ssid: string,
+      password: string,
+      timeout: number,
+      processHandler: Types.GizProvideWiFiCredentialsCallback
+    ) => {
+      return RNGizDeviceManagerModule.provideWiFiCredentials(
+        device.id,
+        'BLE',
+        ssid,
+        password,
+        timeout,
+        processHandler
+      )
+    }
+    device.lanCapability.provideWiFiCredentials = (
+      ssid: string,
+      password: string,
+      timeout: number,
+      processHandler: Types.GizProvideWiFiCredentialsCallback
+    ) => {
+      return RNGizDeviceManagerModule.provideWiFiCredentials(
+        device.id,
+        'LAN',
+        ssid,
+        password,
+        timeout,
+        processHandler
+      )
+    }
+    device.mqttCapability.provideWiFiCredentials = (
+      ssid: string,
+      password: string,
+      timeout: number,
+      processHandler: Types.GizProvideWiFiCredentialsCallback
+    ) => {
+      return RNGizDeviceManagerModule.provideWiFiCredentials(
+        device.id,
+        'MQTT',
+        ssid,
+        password,
+        timeout,
+        processHandler
+      )
+    }
+  }
+
+  deviceDataCallback = (data: DeviceDataRes) => {
+    this.deviceDataCallbacks.map((item) => {
+      item(data)
+    })
+  }
+  deviceListCallback = (data: IDevice[]) => {
+    this.deviceListCallbacks.map((item) => {
+      data.map((d) => {
+        this.appendDeviceFunction(d)
+      })
+      item(data)
+    })
+  }
+  deviceStateCallback = (data: DeviceStateRes) => {
+    this.deviceStateCallbacks.map((item) => {
+      item(data)
+    })
+  }
+  deviceBindCallback = (data: DeviceBindRes) => {
+    this.deviceBindCallbacks.map((item) => {
+      item(data)
+    })
+  }
+
+  async initSDK(config: GizConfigStruct): Promise<Types.GizResult<any, any>> {
+    this.registerListener()
+    return this.callbackWapper((callback: GizCallback<any, any>) => {
+      NativeModules.RNGizSDKManagerModule.initSDK(config, callback)
+    })
+  }
+  async getProductDataPointConfig(
+    productKey: String
+  ): Promise<Types.GizResult<string, any>> {
+    return this.callbackWapper((callback: GizCallback<any, any>) => {
+      NativeModules.RNGizSDKManagerModule.getProductDataPointConfig(
+        { productKey },
+        callback
+      )
+    })
+  }
+
+  async startBleScan(): Promise<Types.GizResult<any, any>> {
+    return this.callbackWapper((callback: GizCallback<any, any>) => {
+      NativeModules.RNGizSDKManagerModule.startBleScan({}, callback)
+    })
+  }
+  async stopBleScan(): Promise<Types.GizResult<any, any>> {
+    return this.callbackWapper((callback: GizCallback<any, any>) => {
+      NativeModules.RNGizSDKManagerModule.stopBleScan({}, callback)
+    })
+  }
+
+  async feedback(
+    uploadLog: boolean,
+    contact: string,
+    content: string
+  ): Promise<Types.GizResult<any, any>> {
+    return this.callbackWapper((callback: GizCallback<any, any>) => {
+      NativeModules.RNGizSDKManagerModule.feedback(
+        { uploadLog, contact, content },
+        callback
+      )
+    })
+  }
+
+  async cleanCache(): Promise<Types.GizResult<any, any>> {
+    return this.callbackWapper((callback: GizCallback<any, any>) => {
+      NativeModules.RNGizSDKManagerModule.cleanCache({}, callback)
+    })
+  }
+  /**
+   * 查询设备列表
+   */
+  async getDevices(): Promise<Types.GizResult<[IDevice], any>> {
+    const data = await this.callbackWapper(
+      (callback: GizCallback<IDevice[], any>) => {
+        NativeModules.RNGizSDKManagerModule.getDevices({}, callback)
+      }
+    )
+    if (data.success) {
+      data.data?.map((item: IDevice) => {
+        // 补充一些方法
+        this.appendDeviceFunction(item)
+      })
+    }
+    return data
+  }
+
+  // 添加监听
+  addDeviceDataListener(callback: DeviceDataCallback) {
+    this.deviceDataCallbacks.push(callback)
+  }
+  addDeviceListListener(callback: DeviceListCallback) {
+    this.deviceListCallbacks.push(callback)
+  }
+  addDeviceStateListener(callback: DeviceStateCallback) {
+    this.deviceStateCallbacks.push(callback)
+  }
+  addDeviceBindStateListener(callback: DeviceBindCallback) {
+    this.deviceBindCallbacks.push(callback)
+  }
+
+  // 解除
+  removeDeviceDataListener(callback: DeviceDataCallback) {
+    this.deleteCallBack(this.deviceDataCallbacks, callback)
+  }
+  removeDeviceListListener(callback: DeviceListCallback) {
+    this.deleteCallBack(this.deviceListCallbacks, callback)
+  }
+  removeDeviceStateListener(callback: DeviceStateCallback) {
+    this.deleteCallBack(this.deviceStateCallbacks, callback)
+  }
+  removeDeviceBindStateListener(callback: DeviceBindCallback) {
+    this.deleteCallBack(this.deviceBindCallbacks, callback)
+  }
+}
+
+const RNGizSDKManagerModule = new RNGizSDKManagerModuleClass()
+export default RNGizSDKManagerModule
+
+export {
+  RNGizDeviceManagerModule,
+  RNGizUserManagerModule,
+  RNGizSDKManagerModule,
+  Types,
+  RNGizSDKManagerModuleClass,
+  RNGizDeviceManagerModuleClass,
+  RNGizUserManagerModuleClass,
+}

package/src/types.ts

@@ -0,0 +1,253 @@
+export type AuthenticationMethod = 0 | 1 // 一型一密 | 一机一密
+
+export interface GizBaseCapability {
+  name: string
+  isActive: boolean
+  isLogin: boolean
+  netStatus: NetStatus
+  connect: () => Promise<GizResult<any, any>>
+  disConnect: () => Promise<GizResult<any, any>>
+  getDeviceInfo: () => Promise<GizResult<GizDeviceInfoProfile, any>>
+  sendDp: (data: Object) => Promise<GizResult<GizDeviceData, any>>
+  getDp: (attrs?: string[]) => Promise<GizResult<GizDeviceData, any>>
+  checkUpdate: (
+    firmwareType: GizOTAFirmwareType
+  ) => Promise<GizResult<GizCheckUpdateResultInfo, any>>
+  startUpgrade: (
+    firmwareType: GizOTAFirmwareType,
+    callback: GizOtaProgressCallback
+  ) => Promise<GizResult<GizCheckUpdateResultInfo, any>>
+  provideWiFiCredentials: (
+    ssid: string,
+    password: string,
+    timeout: number,
+    callback: GizProvideWiFiCredentialsCallback,
+    bindWithUid?: boolean
+  ) => Promise<GizResult<any, any>>
+
+  stopProvideWiFiCredentials: () => Promise<GizResult<any, any>>
+}
+
+export type GizOTAEvent =
+  | 'GizOTAEventCheckingDeviceVersion'
+  | 'GizOTAEventDownloading'
+  | 'GizOTAEventTransferring'
+  | 'GizOTAEventFinish'
+
+export interface LightDanceData {
+  isBeat: boolean
+  bpm: number
+  midiValue: number
+  fft: number[]
+  powerLevel: number
+  hue: number
+}
+export interface GizLightDanceDataEvent {
+  deviceID: string
+  data: LightDanceData
+}
+
+export interface GizOTAProgressData {
+  percentage: number
+  event: GizOTAEvent
+}
+
+// RN 推送的callback
+export type GizOtaProgressEventCallback = (data: {
+  device: IDevice
+  data: GizOTAProgressData
+}) => void
+
+// ota 原始callback
+export type GizOtaProgressCallback = (event: GizOTAProgressData) => void
+
+export type GizProvideWiFiCredentialsCallback = (
+  event: GizWiFiActivatorEvent
+) => void
+
+export type GizMusicalRhythmCallback = (event: GizLightDanceDataEvent) => void
+
+export type MusicalRhythmParseMode = 'ROCK' | 'SOOTHING'
+export interface GizCheckUpdateResultInfo {
+  downloadUrl: string
+  softVersion: string
+  currentSoftVersion: string
+}
+export interface GizBaseProfile {
+  protocolVersion: number
+  supportOTA: boolean
+  requiresAuthentication: boolean
+  authenticationMethod: AuthenticationMethod
+  rootDid?: string
+  configured: boolean
+}
+
+export type BlueToothType = 'Mesh' | 'Beacon' | 'Voice' | 'GATT'
+export type BlueToothVersion = 'BLE4' | 'BLE42' | 'BLE50'
+export type NetStatus = 0 | 1 | 2
+
+export type GizWiFiActivatorEventTypeAndroid =
+  | 'START_WIFI_CONFIG'
+  | 'START_CONNECT_DEVICE'
+  | 'CONNECT_DEVICE_SUCCESS'
+  | 'CONNECT_DEVICE_FAIL'
+  | 'START_SEND_WIFI_CONFIG'
+  | 'START_SEND_WIFI_CONFIG_SUCCESS'
+  | 'START_SEND_WIFI_CONFIG_FAIL'
+  | 'WIFI_CONFIG_RECV_SUCCESS'
+  | 'START_SEARCH_RANDOM_CODE'
+  | 'START_SEARCH_RANDOM_CODE_SUCCESS'
+  | 'WIFI_CONFIG_SUCCESS'
+  | 'WIFI_CONFIG_CANCEL'
+  | 'WIFI_CONFIG_FAIL'
+
+export type GizWiFiActivatorEventTypeiOS =
+  | 1000
+  | 1005
+  | 1006
+  | 1007
+  | 1008
+  | 1009
+  | 1010
+  | 1001
+  | 1011
+  | 1012
+  | 1013
+  | 1014
+  | 1015
+
+export interface GizWiFiActivatorEvent {
+  data: GizWiFiActivatorEventTypeAndroid | GizWiFiActivatorEventTypeiOS
+}
+export interface GizLanProfile extends GizBaseProfile {
+  ip: string
+  port: number
+  cTime: number // 创建时间
+}
+export interface GizBleProfile extends GizBaseProfile {
+  deviceId: string // 设备uuid
+  cTime: number // 创建时间
+  RSSI: number
+  blueToothType: BlueToothType
+  blueToothVersion: BlueToothVersion
+}
+export interface GizMQTTProfile extends GizBaseProfile {
+  host: string
+  port: number
+}
+
+export interface GizBleCapability extends GizBaseCapability {
+  profile: GizBleProfile
+}
+export interface GizLanCapability extends GizBaseCapability {
+  profile: GizLanProfile
+}
+export interface GizMQTTCapability extends GizBaseCapability {
+  profile: GizMQTTProfile
+}
+
+export interface IDevice {
+  id: string
+  mac: string
+  productKey: string
+  did?: string
+  isBind: boolean
+  name: string
+
+  bleCapability: GizBleCapability
+  lanCapability: GizLanCapability
+  mqttCapability: GizMQTTCapability
+
+  startMusicalRhythm: (
+    sensitivity: number,
+    mode: MusicalRhythmParseMode,
+    callback?: GizMusicalRhythmCallback
+  ) => Promise<GizResult<any, any>>
+  stopMusicalRhythm: () => Promise<GizResult<any, any>>
+
+  bind: (alias?: string, remark?: string) => Promise<GizResult<any, any>>
+  updateDeviceInfo: (
+    alias?: string,
+    remark?: string
+  ) => Promise<GizResult<any, any>>
+  unBind: () => Promise<GizResult<any, any>>
+  register: () => Promise<GizResult<any, any>>
+}
+
+export interface IUpdateAuthorizeDataParams {
+  uid: string
+  token: string
+}
+
+export interface GizResult<T, E> {
+  success: boolean
+  message: string
+  data?: T
+  error?: E
+}
+export type GizCallback<T, E> = (
+  error: GizResult<T, E>,
+  data: GizResult<T, E>
+) => void
+export interface ServerInfoStruct {
+  openAPIInfo: string
+}
+export interface ProductInfoStruct {
+  productKey: string
+  productSecret: string
+}
+export interface GizConfigStruct {
+  appID: string
+  appSecret: string
+  productInfos: ProductInfoStruct[]
+  serverInfo?: ServerInfoStruct
+}
+
+export type GizDeviceNetStatus = 0 | 1 | 2
+export type GizCapability = 'BLE' | 'LAN' | 'MQTT'
+export type GizOTAFirmwareType = 'Module' | 'MCU'
+
+export interface DeviceDataRes {
+  device: IDevice
+  data: GizDeviceData
+  type: GizCapability
+}
+export interface DeviceStateRes {
+  device: IDevice
+  state: GizDeviceNetStatus
+  isLogin: boolean
+  type: GizCapability
+}
+export interface DeviceBindRes {
+  did: string
+  isBind: boolean
+}
+export type DeviceDataCallback = (data: DeviceDataRes) => void
+export type DeviceStateCallback = (data: DeviceStateRes) => void
+export type DeviceBindCallback = (data: DeviceBindRes) => void
+export type DeviceListCallback = (data: IDevice[]) => void
+
+// sdk 传递过来的设备状态
+export interface GizDeviceDataItem {
+  [keyof: string]: number | Array<number> | boolean
+}
+export interface GizDeviceData {
+  sn: number
+  cmd: number
+  data: GizDeviceDataItem
+  alerts: GizDeviceDataItem
+  faults: GizDeviceDataItem
+}
+
+export interface GizDeviceInfoProfile {
+  moduleHardVersion: string
+  moduleSoftVersion: string
+  mcuHardVersion: string
+  mcuSoftVersion: string
+  protocolVersion: string
+  serialPortprotocolVersion: string
+  reserve1: string
+  reserve2: string
+  productKey: string
+  hardwareInfo: string
+}