@ray-js/robot-data-stream 0.0.10-beta-14 → 0.0.10-beta-16

package/lib/mqtt/useSchedule.js

@@ -1,11 +1,21 @@
+import "core-js/modules/esnext.iterator.map.js";
 // 定时
+import { useContext } from 'react';
 import { createSetCommonParams } from './createCommonOptions';
 import { normalResolve } from './promise';
 import { ScheduleEnum } from './type';
+import { SingletonContext } from './mqttProvider';
+import { encodeDeviceTimer0x30 } from '@ray-js/robot-protocol';
+import { CISTERN_MAP, CLEAN_MODE_MAP, SUCTION_MAP } from '../constant';
 
 // 定时任务
 
 export const useSchedule = devId => {
+  const {
+    useStructuredMode,
+    devices,
+    commandVersion
+  } = useContext(SingletonContext);
   // 请求定时数据
 
   // 下发定时数据
@@ -23,16 +33,50 @@ export const useSchedule = devId => {
       return normalResolve(ScheduleEnum.query, taskId);
     },
     setSchedule: message => {
-      const params = createSetCommonParams({
-        deviceId: devId,
-        reqType: ScheduleEnum.set,
-        message
+      if (useStructuredMode) {
+        const params = createSetCommonParams({
+          deviceId: devId,
+          reqType: ScheduleEnum.set,
+          message
+        });
+        ty.device.sendMqttMessage(params);
+        const {
+          taskId
+        } = params.message;
+        return normalResolve(ScheduleEnum.query, taskId);
+      }
+      const command = encodeDeviceTimer0x30({
+        version: commandVersion,
+        number: message.num,
+        list: message.list.map(_ref => {
+          let {
+            active,
+            suctions,
+            sweepMopModes,
+            ids,
+            cleanCounts,
+            cycle,
+            cisterns,
+            time
+          } = _ref;
+          return {
+            effectiveness: active,
+            cleanMode: CLEAN_MODE_MAP[sweepMopModes[0]],
+            fanLevel: SUCTION_MAP[suctions[0]],
+            waterLevel: CISTERN_MAP[cisterns[0]],
+            time: {
+              hour: time[0],
+              minute: time[1]
+            },
+            week: cycle,
+            sweepCount: cleanCounts[0],
+            roomIds: ids,
+            roomNum: ids.length
+          };
+        })
       });
-      ty.device.sendMqttMessage(params);
-      const {
-        taskId
-      } = params.message;
-      return normalResolve(ScheduleEnum.query, taskId);
+      devices.common.model.actions.device_timer.set(command);
+      return Promise.resolve();
     }
   };
 };

package/lib/mqtt/useSelectRoomClean.d.ts

@@ -11,14 +11,14 @@ type Response = {
     yMops?: number[];
     sweepMopModes?: string[];
 };
-type TSetRoomClean = (message: {
-    ids: number[];
-    suctions?: string[];
-    cisterns?: string[];
-    cleanCounts?: number[];
-    yMops?: number[];
-    sweepMopModes?: string[];
-}) => Promise<Response>;
+type TSetRoomClean = (rooms: {
+    roomId: number;
+    suction?: string;
+    cistern: string;
+    cleanTimes?: number;
+    yMop?: number;
+    sweepMopMode?: string;
+}[]) => Promise<Response> | Promise<void>;
 export declare const useSelectRoomClean: (devId: string) => {
     requestSelectRoomClean: () => Promise<Response>;
     setRoomClean: TSetRoomClean;

package/lib/mqtt/useSelectRoomClean.js

@@ -1,9 +1,20 @@
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.for-each.js";
+import "core-js/modules/esnext.iterator.map.js";
 // 选区清扫
-import { isArray } from 'lodash-es';
 import { createSetCommonParams } from './createCommonOptions';
 import { RoomCleanSetEnum } from './type';
 import { normalResolve } from './promise';
+import { useContext } from 'react';
+import { SingletonContext } from './mqttProvider';
+import { encodeRoomClean0x14, requestRoomClean0x15 } from '@ray-js/robot-protocol';
 export const useSelectRoomClean = devId => {
+  const {
+    useStructuredMode,
+    commandVersion,
+    devices
+  } = useContext(SingletonContext);
+
   // 请求选区清扫信息
 
   // 设置选区清扫
@@ -11,61 +22,59 @@ export const useSelectRoomClean = devId => {
 
   return {
     requestSelectRoomClean: () => {
-      const params = createSetCommonParams({
-        deviceId: devId,
-        reqType: RoomCleanSetEnum.query
-      });
-      ty.device.sendMqttMessage(params);
-      return normalResolve(RoomCleanSetEnum.query, params.message.taskId);
-    },
-    setRoomClean: message => {
-      const {
-        ids
-      } = message;
-      if (!isArray(ids) || isArray(ids) && ids.length === 0) {
-        return Promise.reject(new Error('ids is required'));
-      }
-      const num = ids.length;
-      const {
-        suctions = new Array(num).fill(''),
-        cisterns = new Array(num).fill(''),
-        cleanCounts = new Array(num).fill(1),
-        yMops = new Array(num).fill(-1),
-        sweepMopModes = new Array(num).fill('only_sweep')
-      } = message;
-      if (suctions && !isArray(suctions)) {
-        return Promise.reject(new Error('suctions is illegal'));
-      }
-      if (cisterns && !isArray(cisterns)) {
-        return Promise.reject(new Error('cisterns is illegal'));
+      if (useStructuredMode) {
+        const params = createSetCommonParams({
+          deviceId: devId,
+          reqType: RoomCleanSetEnum.query
+        });
+        ty.device.sendMqttMessage(params);
+        return normalResolve(RoomCleanSetEnum.query, params.message.taskId);
       }
-      if (cleanCounts && !isArray(cleanCounts)) {
-        return Promise.reject(new Error('cleanCounts is illegal'));
-      }
-      if (yMops && !isArray(yMops)) {
-        return Promise.reject(new Error('yMops is illegal'));
-      }
-      if (sweepMopModes && !isArray(sweepMopModes)) {
-        return Promise.reject(new Error('sweepMopModes is illegal'));
-      }
-      if (num !== suctions.length || num !== cisterns.length || num !== cleanCounts.length || num !== yMops.length || num !== sweepMopModes.length) {
-        return Promise.reject(new Error('The length of the parameters is inconsistent'));
+      return devices.common.model.actions.command_trans.set(requestRoomClean0x15({
+        version: commandVersion
+      }));
+    },
+    setRoomClean: rooms => {
+      var _rooms$0$cleanTimes, _rooms$;
+      if (useStructuredMode) {
+        const ids = [];
+        const suctions = [];
+        const cisterns = [];
+        const cleanCounts = [];
+        const yMops = [];
+        const sweepMopModes = [];
+        rooms.forEach(room => {
+          var _room$suction, _room$cleanTimes, _room$yMop, _room$sweepMopMode;
+          ids.push(room.roomId);
+          suctions.push((_room$suction = room.suction) !== null && _room$suction !== void 0 ? _room$suction : '');
+          cisterns.push(room.cistern);
+          cleanCounts.push((_room$cleanTimes = room.cleanTimes) !== null && _room$cleanTimes !== void 0 ? _room$cleanTimes : 1);
+          yMops.push((_room$yMop = room.yMop) !== null && _room$yMop !== void 0 ? _room$yMop : -1);
+          sweepMopModes.push((_room$sweepMopMode = room.sweepMopMode) !== null && _room$sweepMopMode !== void 0 ? _room$sweepMopMode : 'only_sweep');
+        });
+        const params = createSetCommonParams({
+          deviceId: devId,
+          reqType: RoomCleanSetEnum.set,
+          message: {
+            ids,
+            suctions,
+            cisterns,
+            cleanCounts,
+            yMops,
+            sweepMopModes,
+            num: rooms.length
+          }
+        });
+        ty.device.sendMqttMessage(params);
+        return normalResolve(RoomCleanSetEnum.query, params.message.taskId);
       }
-      const params = createSetCommonParams({
-        deviceId: devId,
-        reqType: RoomCleanSetEnum.set,
-        message: {
-          ids,
-          suctions,
-          cisterns,
-          cleanCounts,
-          yMops,
-          sweepMopModes,
-          num: ids.length
-        }
+      const command = encodeRoomClean0x14({
+        version: commandVersion,
+        roomIds: rooms.map(room => room.roomId),
+        cleanTimes: (_rooms$0$cleanTimes = (_rooms$ = rooms[0]) === null || _rooms$ === void 0 ? void 0 : _rooms$.cleanTimes) !== null && _rooms$0$cleanTimes !== void 0 ? _rooms$0$cleanTimes : 1
       });
-      ty.device.sendMqttMessage(params);
-      return normalResolve(RoomCleanSetEnum.query, params.message.taskId);
+      devices.common.model.actions.command_trans.set(command);
+      return Promise.resolve();
     }
   };
 };

package/lib/mqtt/useSpotClean.d.ts

@@ -1,12 +1,13 @@
 import { RoomPreference } from './type';
+import { Point } from '@ray-js/robot-protocol';
 type Response = Partial<Pick<RoomPreference, 'suctions' | 'cisterns' | 'cleanCounts' | 'yMops' | 'sweepMopModes'>> & {
     polygons: string[];
     names?: string[];
 };
 type TSetSpotClean = (message: Partial<Pick<RoomPreference, 'suctions' | 'cisterns' | 'cleanCounts' | 'yMops' | 'sweepMopModes'>> & {
-    polygons: string[];
-    names?: string[];
-}) => Promise<Response>;
+    spots: Point[];
+    origin?: Point;
+}) => Promise<Response | void>;
 /**
  * 定点清扫
  * @returns

package/lib/mqtt/useSpotClean.js

@@ -4,11 +4,21 @@ import { isArray } from 'lodash-es';
 import { createSetCommonParams } from './createCommonOptions';
 import { normalResolve } from './promise';
 import { SpotCleanEnum } from './type';
+import { useContext } from 'react';
+import { SingletonContext } from './mqttProvider';
+import { encodeSpotClean0x16 } from '@ray-js/robot-protocol';
+import { pointsToString } from '../utils';
 /**
  * 定点清扫
  * @returns
  */
 export const useSpotClean = devId => {
+  const {
+    useStructuredMode,
+    commandVersion,
+    devices
+  } = useContext(SingletonContext);
+
   // 请求定点清扫数据
 
   // 设置定点清扫
@@ -25,57 +35,67 @@ export const useSpotClean = devId => {
     },
     setSpotClean: message => {
       const {
-        polygons
-      } = message;
-      if (!isArray(polygons) || isArray(polygons) && polygons.length === 0) {
-        return Promise.reject(new Error('message is required'));
-      }
-      const num = polygons.length;
-      const {
-        suctions = new Array(num).fill(''),
-        cisterns = new Array(num).fill(''),
-        cleanCounts = new Array(num).fill(1),
-        yMops = new Array(num).fill(-1),
-        sweepMopModes = new Array(num).fill('only_sweep'),
-        names = new Array(num).fill('')
+        spots,
+        origin
       } = message;
-      if (suctions && !isArray(suctions)) {
-        return Promise.reject(new Error('suctions is illegal'));
-      }
-      if (cisterns && !isArray(cisterns)) {
-        return Promise.reject(new Error('cisterns is illegal'));
-      }
-      if (cleanCounts && !isArray(cleanCounts)) {
-        return Promise.reject(new Error('cleanCounts is illegal'));
-      }
-      if (yMops && !isArray(yMops)) {
-        return Promise.reject(new Error('yMops is illegal'));
-      }
-      if (sweepMopModes && !isArray(sweepMopModes)) {
-        return Promise.reject(new Error('sweepMopModes is illegal'));
-      }
-      if (names && !isArray(names)) {
-        return Promise.reject(new Error('names is illegal'));
-      }
-      if (num !== suctions.length || num !== cisterns.length || num !== cleanCounts.length || num !== yMops.length || num !== sweepMopModes.length || num !== names.length) {
-        return Promise.reject(new Error('The length of the parameters is inconsistent'));
-      }
-      const params = createSetCommonParams({
-        deviceId: devId,
-        reqType: SpotCleanEnum.set,
-        message: {
-          num,
-          polygons,
-          suctions,
-          cisterns,
-          cleanCounts,
-          yMops,
-          sweepMopModes,
-          names
+      if (useStructuredMode) {
+        if (!isArray(spots) || isArray(spots) && spots.length === 0) {
+          return Promise.reject(new Error('message is required'));
+        }
+        const num = spots.length;
+        const {
+          suctions = new Array(num).fill(''),
+          cisterns = new Array(num).fill(''),
+          cleanCounts = new Array(num).fill(1),
+          yMops = new Array(num).fill(-1),
+          sweepMopModes = new Array(num).fill('only_sweep')
+        } = message;
+        const names = new Array(num).fill('');
+        if (suctions && !isArray(suctions)) {
+          return Promise.reject(new Error('suctions is illegal'));
+        }
+        if (cisterns && !isArray(cisterns)) {
+          return Promise.reject(new Error('cisterns is illegal'));
+        }
+        if (cleanCounts && !isArray(cleanCounts)) {
+          return Promise.reject(new Error('cleanCounts is illegal'));
+        }
+        if (yMops && !isArray(yMops)) {
+          return Promise.reject(new Error('yMops is illegal'));
+        }
+        if (sweepMopModes && !isArray(sweepMopModes)) {
+          return Promise.reject(new Error('sweepMopModes is illegal'));
         }
+        if (names && !isArray(names)) {
+          return Promise.reject(new Error('names is illegal'));
+        }
+        if (num !== suctions.length || num !== cisterns.length || num !== cleanCounts.length || num !== yMops.length || num !== sweepMopModes.length || num !== names.length) {
+          return Promise.reject(new Error('The length of the parameters is inconsistent'));
+        }
+        const params = createSetCommonParams({
+          deviceId: devId,
+          reqType: SpotCleanEnum.set,
+          message: {
+            num,
+            polygons: [pointsToString(spots, origin)],
+            suctions,
+            cisterns,
+            cleanCounts,
+            yMops,
+            sweepMopModes,
+            names
+          }
+        });
+        ty.device.sendMqttMessage(params);
+        return normalResolve(SpotCleanEnum.query, params.message.taskId);
+      }
+      const command = encodeSpotClean0x16({
+        version: commandVersion,
+        origin,
+        point: spots[0]
       });
-      ty.device.sendMqttMessage(params);
-      return normalResolve(SpotCleanEnum.query, params.message.taskId);
+      devices.common.model.actions.command_trans.set(command);
+      return Promise.resolve();
     }
   };
 };

package/lib/mqtt/useVirtualArea.d.ts

@@ -1,3 +1,4 @@
+import { Point, VirtualArea } from '@ray-js/robot-protocol';
 type Response = {
     reqType: 'restrictedAreaQry';
     version: string;
@@ -11,11 +12,9 @@ type Response = {
     taskId: string;
 };
 type TSetVirtualArea = (message: {
-    polygons: string[];
-    names?: string[];
-    modes: number[];
-    num?: number;
-}) => Promise<Response>;
+    data: VirtualArea[];
+    origin: Point;
+}) => Promise<Response> | Promise<void>;
 type TRequestVirtualArea = () => Promise<Response>;
 export declare const useVirtualArea: (devId: string) => {
     requestVirtualArea: TRequestVirtualArea;

package/lib/mqtt/useVirtualArea.js

@@ -1,11 +1,22 @@
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.for-each.js";
 // 添加禁区
+import { useContext } from 'react';
 import { createSetCommonParams } from './createCommonOptions';
 import { normalResolve } from './promise';
 import { VirtualAreaEnum } from './type';
-import { isArray } from 'lodash-es';
+import { SingletonContext } from './mqttProvider';
+import { encodeVirtualArea0x1a, requestVirtualArea0x1b } from '@ray-js/robot-protocol';
+import { pointsToString } from '../utils';
 // 禁区
 
 export const useVirtualArea = devId => {
+  const {
+    useStructuredMode,
+    commandVersion,
+    devices
+  } = useContext(SingletonContext);
+
   /**
    * 请求虚拟区域数据
    * @returns Promise<VirtualAreaResponse> 响应结果
@@ -23,57 +34,57 @@ export const useVirtualArea = devId => {
 
   return {
     requestVirtualArea: () => {
-      const params = createSetCommonParams({
-        deviceId: devId,
-        reqType: VirtualAreaEnum.query
-      });
-      ty.device.sendMqttMessage(params);
-      return normalResolve(VirtualAreaEnum.query, params.message.taskId);
-    },
-    setVirtualArea: message => {
-      const {
-        polygons,
-        num,
-        modes,
-        names
-      } = message || {};
-      if (!isArray(polygons) || isArray(polygons) && polygons.length === 0) {
-        return Promise.reject(new Error('message polygons is required'));
-      }
-      const len = polygons.length;
-      if (!isArray(message.modes) || isArray(message.modes) && message.modes.length === 0) {
-        return Promise.reject(new Error('message modes is required'));
-      }
-      if (num && !Number.isInteger(num)) {
-        return Promise.reject(new Error('num is illegal'));
+      if (useStructuredMode) {
+        const params = createSetCommonParams({
+          deviceId: devId,
+          reqType: VirtualAreaEnum.query
+        });
+        ty.device.sendMqttMessage(params);
+        return normalResolve(VirtualAreaEnum.query, params.message.taskId);
       }
-      if (num && num !== len) {
-        return Promise.reject(new Error('num is not equal to points length'));
-      }
-      if (modes && !isArray(modes)) {
-        return Promise.reject(new Error('mode is illegal'));
-      }
-      if (modes && modes.length !== len) {
-        return Promise.reject(new Error('mode length is not equal to points length'));
-      }
-      if (names && !isArray(names)) {
-        return Promise.reject(new Error('names is illegal'));
-      }
-      if (names && names.length !== len) {
-        return Promise.reject(new Error('names length is not equal to points length'));
+      return devices.common.model.actions.command_trans.set(requestVirtualArea0x1b({
+        version: commandVersion
+      }));
+    },
+    setVirtualArea: _ref => {
+      let {
+        data,
+        origin
+      } = _ref;
+      if (useStructuredMode) {
+        const names = [];
+        const modes = [];
+        const polygons = [];
+        data.forEach(_ref2 => {
+          let {
+            points,
+            name,
+            mode
+          } = _ref2;
+          names.push(name);
+          modes.push(mode);
+          polygons.push(pointsToString(points, origin));
+        });
+        const params = createSetCommonParams({
+          deviceId: devId,
+          reqType: VirtualAreaEnum.set,
+          message: {
+            polygons,
+            num: data.length,
+            modes: modes,
+            names: names
+          }
+        });
+        ty.device.sendMqttMessage(params);
+        return normalResolve(VirtualAreaEnum.query, params.message.taskId);
       }
-      const params = createSetCommonParams({
-        deviceId: devId,
-        reqType: VirtualAreaEnum.set,
-        message: {
-          polygons,
-          num: num || len,
-          modes: modes || new Array(len).fill(0),
-          names: names || new Array(len).fill('')
-        }
+      const command = encodeVirtualArea0x1a({
+        version: commandVersion,
+        origin,
+        virtualAreas: data
       });
-      ty.device.sendMqttMessage(params);
-      return normalResolve(VirtualAreaEnum.query, params.message.taskId);
+      devices.common.model.actions.command_trans.set(command);
+      return Promise.resolve();
     }
   };
 };

package/lib/mqtt/useVirtualWall.d.ts

@@ -1,3 +1,4 @@
+import { Point } from '@ray-js/robot-protocol';
 type Response = {
     modes: number[];
     success: boolean;
@@ -10,11 +11,10 @@ type Response = {
     points: string[];
 };
 type TRequestVirtualWall = () => Promise<Response>;
-type TSetVirtualWall = (message: {
-    points: string[];
-    num?: number;
-    mode?: number[];
-}) => Promise<Response>;
+type TSetVirtualWall = (params: {
+    data: Point[][];
+    origin: Point;
+}) => Promise<Response> | Promise<void>;
 export declare const useVirtualWall: (devId: string) => {
     requestVirtualWall: TRequestVirtualWall;
     setVirtualWall: TSetVirtualWall;

package/lib/mqtt/useVirtualWall.js

@@ -1,11 +1,20 @@
-import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import "core-js/modules/esnext.iterator.map.js";
 // 虚拟墙数据
 
+import { useContext } from 'react';
 import { createSetCommonParams } from './createCommonOptions';
 import { normalResolve } from './promise';
 import { VirtualWallEnum } from './type';
-import { isArray } from 'lodash-es';
+import { SingletonContext } from './mqttProvider';
+import { encodeVirtualWall0x12, requestVirtualWall0x13 } from '@ray-js/robot-protocol';
+import { pointsToString } from '../utils';
 export const useVirtualWall = devId => {
+  const {
+    useStructuredMode,
+    commandVersion,
+    devices
+  } = useContext(SingletonContext);
+
   // 请求虚拟墙数据
 
   /**
@@ -19,47 +28,43 @@ export const useVirtualWall = devId => {
 
   return {
     requestVirtualWall: () => {
-      const params = createSetCommonParams({
-        deviceId: devId,
-        reqType: VirtualWallEnum.query
-      });
-      ty.device.sendMqttMessage(params);
-      return normalResolve(VirtualWallEnum.query, params.message.taskId);
-    },
-    setVirtualWall: message => {
-      const requestParams = _objectSpread({}, message);
-      if (!isArray(requestParams.points) || requestParams.points.length === 0) {
-        return Promise.reject(new Error('points is illegal'));
-      }
-      const len = requestParams.points.length;
-      if (requestParams.num && !Number.isInteger(requestParams.num)) {
-        return Promise.reject(new Error('num is illegal'));
+      if (useStructuredMode) {
+        const params = createSetCommonParams({
+          deviceId: devId,
+          reqType: VirtualWallEnum.query
+        });
+        ty.device.sendMqttMessage(params);
+        return normalResolve(VirtualWallEnum.query, params.message.taskId);
       }
-      if (requestParams.num && requestParams.num !== len) {
-        return Promise.reject(new Error('num is not equal to points length'));
-      }
-      if (requestParams.mode && !isArray(requestParams.mode)) {
-        return Promise.reject(new Error('mode is illegal'));
-      }
-      if (requestParams.mode && requestParams.mode.length !== len) {
-        return Promise.reject(new Error('mode length is not equal to points length'));
+      return devices.common.model.actions.command_trans.set(requestVirtualWall0x13({
+        version: commandVersion
+      }));
+    },
+    setVirtualWall: _ref => {
+      let {
+        data,
+        origin
+      } = _ref;
+      if (useStructuredMode) {
+        const params = createSetCommonParams({
+          deviceId: devId,
+          reqType: VirtualWallEnum.set,
+          message: {
+            points: data.map(points => pointsToString(points, origin)),
+            num: data.length,
+            mode: new Array(data.length).fill('0')
+          }
+        });
+        ty.device.sendMqttMessage(params);
+        return normalResolve(VirtualWallEnum.query, params.message.taskId);
       }
-      const {
-        points,
-        num,
-        mode
-      } = requestParams;
-      const params = createSetCommonParams({
-        deviceId: devId,
-        reqType: VirtualWallEnum.set,
-        message: {
-          points,
-          num: num || len,
-          mode: mode || new Array(len).fill(-1)
-        }
+      const command = encodeVirtualWall0x12({
+        version: commandVersion,
+        origin,
+        walls: data
       });
-      ty.device.sendMqttMessage(params);
-      return normalResolve(VirtualWallEnum.query, params.message.taskId);
+      devices.common.model.actions.command_trans.set(command);
+      return Promise.resolve();
     }
   };
 };