@ray-js/robot-data-stream 0.0.10-beta-11 → 0.0.10-beta-13

package/lib/mqtt/useHistoryMap.js

@@ -0,0 +1,91 @@
+import { deleteMultipleMapFile } from '../api/deleteMultipleMapFile';
+import { createSetCommonParams } from './createCommonOptions';
+import { normalResolve } from './promise';
+import { DeleteMapEnum, SaveCurrentMapEnum, UseMapEnum } from './type';
+
+// 删除历史地图函数类型定义
+
+// 更改当前使用的地图函数类型定义
+
+/**
+ * 自定义 Hook，用于管理历史地图
+ * @param devId 设备ID
+ * @returns 包含删除历史地图、更改当前地图和保存地图的函数
+ */
+export const useHistoryMap = devId => {
+  /**
+   * 删除历史地图
+   * @param mapId 地图ID
+   * @returns Promise<{ success: boolean; errCode: number; reqType: string; version: string; taskId: string; }> 响应结果
+   */
+
+  /**
+   * 保存当前地图
+   * @returns Promise<void> 响应结果
+   */
+
+  /**
+   * 更改当前使用的地图
+   * @param mapId 地图ID
+   * @param url 地图URL
+   * @returns Promise<{ success: boolean; errCode: number; reqType: string; mapId: number; version: string; taskId: string; }> 响应结果
+   */
+
+  return {
+    deleteHistoryMap: async mapId => {
+      try {
+        if (!mapId) {
+          return Promise.reject(new Error('mapId is required'));
+        }
+        await deleteMultipleMapFile(mapId, devId);
+        const params = createSetCommonParams({
+          deviceId: devId,
+          reqType: DeleteMapEnum.set,
+          message: {
+            mapId
+          }
+        });
+        ty.device.sendMqttMessage(params);
+        const {
+          taskId
+        } = params.message;
+        return await normalResolve(DeleteMapEnum.rst, taskId);
+      } catch (err) {
+        return Promise.reject(err);
+      }
+    },
+    changeCurrentMap: async (mapId, url) => {
+      try {
+        const sendData = {
+          reqType: UseMapEnum.set,
+          mapId,
+          url,
+          urlLen: url.length
+        };
+        const params = createSetCommonParams({
+          deviceId: devId,
+          reqType: UseMapEnum.set,
+          message: sendData
+        });
+        ty.device.sendMqttMessage(params);
+        const {
+          taskId
+        } = params.message;
+        return await normalResolve(UseMapEnum.query, taskId);
+      } catch (err) {
+        return Promise.reject(err);
+      }
+    },
+    saveMap: () => {
+      const params = createSetCommonParams({
+        deviceId: devId,
+        reqType: SaveCurrentMapEnum.set,
+        message: {
+          oper: 0
+        }
+      });
+      ty.device.sendMqttMessage(params);
+      return normalResolve(SaveCurrentMapEnum.query, params.message.taskId);
+    }
+  };
+};

package/lib/mqtt/usePartDivision.d.ts

@@ -0,0 +1,17 @@
+import { Point } from '../utils';
+type TSetPartDivision = (points: Point[], roomId: number, origin: Point) => Promise<{
+    success: boolean;
+    errCode: number;
+    reqType: string;
+    version: string;
+    taskId: string;
+}>;
+/**
+ * 自定义 Hook，用于房间分隔
+ * @param devId 设备ID
+ * @returns 包含 setPartDivision 函数的对象
+ */
+export declare const usePartDivision: (devId: string) => {
+    setPartDivision: TSetPartDivision;
+};
+export {};

package/lib/mqtt/usePartDivision.js

@@ -0,0 +1,38 @@
+// 房间分隔
+import { pointsToString } from '../utils';
+import { createSetCommonParams } from './createCommonOptions';
+import { normalResolve } from './promise';
+import { PartDivisionEnum } from './type';
+
+// 设置房间分隔函数类型定义
+
+/**
+ * 自定义 Hook，用于房间分隔
+ * @param devId 设备ID
+ * @returns 包含 setPartDivision 函数的对象
+ */
+export const usePartDivision = devId => {
+  /**
+   * 设置房间分隔
+   * @param points 分隔点数组，SDK方法抛出来的坐标直接传入即可
+   * @param roomId 房间ID,当前要分隔的房间
+   * @param origin 地图原点坐标
+   * @returns Promise<Response> 响应结果
+   */
+
+  return {
+    setPartDivision: (points, roomId, origin) => {
+      const pointStr = pointsToString(points, origin);
+      const params = createSetCommonParams({
+        deviceId: devId,
+        reqType: PartDivisionEnum.set,
+        message: {
+          lines: [pointStr],
+          ids: [roomId]
+        }
+      });
+      ty.device.sendMqttMessage(params);
+      return normalResolve(PartDivisionEnum.query, params.message.taskId);
+    }
+  };
+};

package/lib/mqtt/usePartMerge.d.ts

@@ -0,0 +1,16 @@
+type TSetPartMerge = (ids: number[]) => Promise<{
+    success: boolean;
+    errCode: number;
+    reqType: string;
+    version: string;
+    taskId: string;
+}>;
+/**
+ * 自定义 Hook，用于分区合并
+ * @param devId 设备ID
+ * @returns 包含 setPartMerge 函数的对象
+ */
+export declare const usePartMerge: (devId: string) => {
+    setPartMerge: TSetPartMerge;
+};
+export {};

package/lib/mqtt/usePartMerge.js

@@ -0,0 +1,41 @@
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.some.js";
+// 分区合并
+import { createSetCommonParams } from './createCommonOptions';
+import { normalResolve } from './promise';
+import { PartMergeEnum } from './type';
+
+// 设置分区合并函数类型定义
+
+/**
+ * 自定义 Hook，用于分区合并
+ * @param devId 设备ID
+ * @returns 包含 setPartMerge 函数的对象
+ */
+export const usePartMerge = devId => {
+  /**
+   * 设置分区合并
+   * @param ids 要合并的分区ID数组
+   * @returns Promise<Response> 响应结果
+   */
+
+  return {
+    setPartMerge: ids => {
+      if (!ids || ids.length < 2) {
+        return Promise.reject(new Error('ids is required and length must be greater than 1'));
+      }
+      if (ids.some(id => typeof id !== 'number')) {
+        return Promise.reject(new Error('ids must be an array of numbers'));
+      }
+      const params = createSetCommonParams({
+        deviceId: devId,
+        reqType: PartMergeEnum.set,
+        message: {
+          ids
+        }
+      });
+      ty.device.sendMqttMessage(params);
+      return normalResolve(PartMergeEnum.query, params.message.taskId);
+    }
+  };
+};

package/lib/mqtt/usePassword.d.ts

@@ -0,0 +1,17 @@
+import { PromiseWithRejection } from './promise';
+type TRequestPassword = () => PromiseWithRejection;
+type TSetPassword = (params: {
+    password: string;
+    oldPassword?: string;
+    taskId?: string;
+}) => PromiseWithRejection;
+type TCheckPassword = (params: {
+    password: string;
+    taskId?: string;
+}) => PromiseWithRejection;
+export declare const usePassword: (devId: string) => {
+    requestPassword: TRequestPassword;
+    setPassword: TSetPassword;
+    checkPassword: TCheckPassword;
+};
+export {};

package/lib/mqtt/usePassword.js

@@ -0,0 +1,56 @@
+import md5 from 'crypto-js/md5';
+import { createSetCommonParams } from './createCommonOptions';
+import { normalResolve } from './promise';
+import { PasswordEnum } from './type';
+export const usePassword = devId => {
+  // 请求密码状态
+
+  // 设置密码
+
+  // 校验密码
+
+  return {
+    requestPassword: () => {
+      const params = createSetCommonParams({
+        deviceId: devId,
+        reqType: PasswordEnum.query
+      });
+      ty.device.sendMqttMessage(params);
+      return normalResolve(PasswordEnum.query, params.message.taskId);
+    },
+    setPassword: _ref => {
+      let {
+        password,
+        oldPassword,
+        taskId
+      } = _ref;
+      const params = createSetCommonParams({
+        deviceId: devId,
+        reqType: PasswordEnum.set,
+        message: {
+          taskId: taskId !== null && taskId !== void 0 ? taskId : String(Date.now()),
+          password: md5(password).toString(),
+          oldPassword: oldPassword ? md5(oldPassword).toString() : undefined
+        }
+      });
+      ty.device.sendMqttMessage(params);
+      return normalResolve(PasswordEnum.rst, params.message.taskId);
+    },
+    checkPassword: _ref2 => {
+      let {
+        password,
+        taskId
+      } = _ref2;
+      const params = createSetCommonParams({
+        deviceId: devId,
+        reqType: PasswordEnum.check,
+        message: {
+          taskId: taskId !== null && taskId !== void 0 ? taskId : String(Date.now()),
+          password: md5(password).toString()
+        }
+      });
+      ty.device.sendMqttMessage(params);
+      return normalResolve(PasswordEnum.checkRst, params.message.taskId);
+    }
+  };
+};

package/lib/mqtt/useQuiteHours.d.ts

@@ -0,0 +1,55 @@
+type Response = {
+    reqType: string;
+    /**
+     * 版本号
+     */
+    version: string;
+    /**
+     * 是否激活
+     * 0 表示未激活，1 表示激活
+     */
+    active: number;
+    /**
+     * 时间段数组，每个元素为 "开始时间, 结束时间" 的字符串
+     */
+    time: string[];
+    /**
+     * 星期几，1 表示星期一，2 表示星期二，以此类推
+     */
+    day: number;
+    /**
+     * 请求是否成功
+     */
+    success: boolean;
+    /**
+     * 错误代码，0 表示无错误
+     */
+    errCode: number;
+    /**
+     * 任务ID
+     */
+    taskId: string;
+};
+type TSetQuiteHours = (params: {
+    startTime: {
+        hour: number;
+        minute: number;
+    };
+    endTime: {
+        hour: number;
+        minute: number;
+    };
+    active: number;
+    day: number;
+    version?: string;
+}) => Promise<Response>;
+/**
+ * 自定义 Hook，用于勿扰模式
+ * @param devId 设备ID
+ * @returns 包含 setQuiteHours 和 requestQuiteHours 函数的对象
+ */
+export declare const useQuiteHours: (devId: string) => {
+    setQuiteHours: TSetQuiteHours;
+    requestQuiteHours: () => Promise<Response>;
+};
+export {};

package/lib/mqtt/useQuiteHours.js

@@ -0,0 +1,71 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+const _excluded = ["startTime", "endTime"];
+// 勿扰模式
+import { createSetCommonParams } from './createCommonOptions';
+import { normalResolve } from './promise';
+import { QuietHoursEnum } from './type';
+
+// 设置勿扰模式函数类型定义
+
+/**
+ * 自定义 Hook，用于勿扰模式
+ * @param devId 设备ID
+ * @returns 包含 setQuiteHours 和 requestQuiteHours 函数的对象
+ */
+export const useQuiteHours = devId => {
+  /**
+   * 请求勿扰模式数据
+   * @returns Promise<{ time: string[]; day: number; active: number }> 响应结果
+   */
+
+  /**
+   * 设置勿扰模式
+   * @param message 包含勿扰模式设置参数的对象
+   * @returns Promise<Response> 响应结果
+   */
+
+  return {
+    setQuiteHours: message => {
+      const {
+          startTime,
+          endTime
+        } = message,
+        others = _objectWithoutProperties(message, _excluded);
+      if (!startTime || !endTime) {
+        throw new Error('Invalid time');
+      }
+      const {
+        hour: h0,
+        minute: m0
+      } = startTime;
+      const {
+        hour: h1,
+        minute: m1
+      } = endTime;
+      if (h0 > 23 || h0 < 0 || h1 > 23 || h1 < 0 || m0 > 59 || m0 < 0 || m1 > 59 || m1 < 0) {
+        throw new Error('Invalid time');
+      }
+      const params = createSetCommonParams({
+        deviceId: devId,
+        reqType: QuietHoursEnum.set,
+        message: _objectSpread({
+          time: [`${h0},${m0}`, `${h1},${m1}`]
+        }, others)
+      });
+      ty.device.sendMqttMessage(params);
+      return normalResolve(QuietHoursEnum.query, params.message.taskId);
+    },
+    requestQuiteHours: () => {
+      const params = createSetCommonParams({
+        deviceId: devId,
+        reqType: QuietHoursEnum.query
+      });
+      ty.device.sendMqttMessage(params);
+      const {
+        taskId
+      } = params.message;
+      return normalResolve(QuietHoursEnum.query, taskId);
+    }
+  };
+};

package/lib/mqtt/useResetMap.d.ts

@@ -0,0 +1,11 @@
+type TSetResetMap = () => Promise<{
+    success: boolean;
+    errCode: number;
+    reqType: string;
+    version: string;
+    taskId: string;
+}>;
+export declare const useResetMap: (devId: string) => {
+    setResetMap: TSetResetMap;
+};
+export {};

package/lib/mqtt/useResetMap.js

@@ -0,0 +1,17 @@
+import { createSetCommonParams } from './createCommonOptions';
+import { normalResolve } from './promise';
+import { ResetCurrMapEnum } from './type';
+export const useResetMap = devId => {
+  // 重置地图
+
+  return {
+    setResetMap: () => {
+      const params = createSetCommonParams({
+        deviceId: devId,
+        reqType: ResetCurrMapEnum.set
+      });
+      ty.device.sendMqttMessage(params);
+      return normalResolve(ResetCurrMapEnum.query, params.message.taskId);
+    }
+  };
+};

package/lib/mqtt/useRoomProperty.d.ts

@@ -0,0 +1,11 @@
+import { BaseResponse, RoomPreference } from './type';
+type Response = BaseResponse & RoomPreference & {
+    num: number;
+    mapId: number;
+};
+type TSetRoomProperty = (message: Pick<Response, 'num' | 'suctions' | 'cisterns' | 'floorTypes' | 'names' | 'orders' | 'yMops' | 'sweepMopModes' | 'cleanCounts' | 'ids'>) => Promise<RoomPreference>;
+export declare const useRoomProperty: (devId: string) => {
+    requestRoomProperty: () => Promise<Response>;
+    setRoomProperty: TSetRoomProperty;
+};
+export {};

package/lib/mqtt/useRoomProperty.js

@@ -0,0 +1,66 @@
+import { isArray } from 'lodash-es';
+import { createSetCommonParams } from './createCommonOptions';
+import { normalResolve } from './promise';
+import { RoomPropertyEnum } from './type';
+export const useRoomProperty = devId => {
+  // 请求房间属性
+
+  // 设置房间属性
+
+  return {
+    requestRoomProperty: () => {
+      const params = createSetCommonParams({
+        deviceId: devId,
+        reqType: RoomPropertyEnum.query
+      });
+      ty.device.sendMqttMessage(params);
+      return normalResolve(RoomPropertyEnum.query, params.message.taskId);
+    },
+    setRoomProperty: message => {
+      const params = createSetCommonParams({
+        deviceId: devId,
+        reqType: RoomPropertyEnum.set,
+        message
+      });
+      const {
+        ids
+      } = message;
+      if (!isArray(ids) || isArray(ids) && ids.length === 0) {
+        return Promise.reject(new Error('ids is required'));
+      }
+      const len = ids.length;
+      const {
+        suctions = new Array(len).fill('closed'),
+        cisterns = new Array(len).fill('closed'),
+        cleanCounts = new Array(len).fill(1),
+        yMops = new Array(len).fill(-1),
+        sweepMopModes = new Array(len).fill('only_sweep'),
+        names = new Array(len).fill('')
+      } = message;
+      if (suctions && !isArray(suctions)) {
+        // 设置超时定时器
+        return Promise.reject(new Error('cisterns 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 (len !== suctions.length || len !== cisterns.length || len !== cleanCounts.length || len !== yMops.length || len !== sweepMopModes.length || len !== names.length) {
+        return Promise.reject(new Error('The length of the parameters is inconsistent'));
+      }
+      ty.device.sendMqttMessage(params);
+      return normalResolve(RoomPropertyEnum.query, params.message.taskId);
+    }
+  };
+};

package/lib/mqtt/useSchedule.d.ts

@@ -0,0 +1,16 @@
+import { RoomPreference, BaseResponse } from './type';
+type ScheduleItem = Pick<RoomPreference, 'suctions' | 'cisterns' | 'cleanCounts' | 'yMops' | 'sweepMopModes' | 'ids'> & {
+    active: number;
+    cycle: number[];
+    time: number[];
+};
+interface Schedule {
+    list: Array<ScheduleItem>;
+    num: number;
+}
+type Response = BaseResponse & Schedule;
+export declare const useSchedule: (devId: string) => {
+    requestSchedule: () => Promise<Response>;
+    setSchedule: (message: Schedule) => Promise<Response>;
+};
+export {};

package/lib/mqtt/useSchedule.js

@@ -0,0 +1,38 @@
+// 定时
+import { createSetCommonParams } from './createCommonOptions';
+import { normalResolve } from './promise';
+import { ScheduleEnum } from './type';
+
+// 定时任务
+
+export const useSchedule = devId => {
+  // 请求定时数据
+
+  // 下发定时数据
+
+  return {
+    requestSchedule: () => {
+      const params = createSetCommonParams({
+        deviceId: devId,
+        reqType: ScheduleEnum.query
+      });
+      ty.device.sendMqttMessage(params);
+      const {
+        taskId
+      } = params.message;
+      return normalResolve(ScheduleEnum.query, taskId);
+    },
+    setSchedule: message => {
+      const params = createSetCommonParams({
+        deviceId: devId,
+        reqType: ScheduleEnum.set,
+        message
+      });
+      ty.device.sendMqttMessage(params);
+      const {
+        taskId
+      } = params.message;
+      return normalResolve(ScheduleEnum.query, taskId);
+    }
+  };
+};

package/lib/mqtt/useSelectRoomClean.d.ts

@@ -0,0 +1,26 @@
+type Response = {
+    reqType: string;
+    version: string;
+    success: boolean;
+    errCode: number;
+    taskId: string;
+    ids: number[];
+    suctions?: string[];
+    cisterns?: string[];
+    cleanCounts?: number[];
+    yMops?: number[];
+    sweepMopModes?: string[];
+};
+type TSetRoomClean = (message: {
+    ids: number[];
+    suctions?: string[];
+    cisterns?: string[];
+    cleanCounts?: number[];
+    yMops?: number[];
+    sweepMopModes?: string[];
+}) => Promise<Response>;
+export declare const useSelectRoomClean: (devId: string) => {
+    requestSelectRoomClean: () => Promise<Response>;
+    setRoomClean: TSetRoomClean;
+};
+export {};

package/lib/mqtt/useSelectRoomClean.js

@@ -0,0 +1,70 @@
+// 选区清扫
+import { isArray } from 'lodash-es';
+import { createSetCommonParams } from './createCommonOptions';
+import { RoomCleanSetEnum } from './type';
+import { normalResolve } from './promise';
+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 (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'));
+      }
+      const params = createSetCommonParams({
+        deviceId: devId,
+        reqType: RoomCleanSetEnum.set,
+        message: {
+          ids,
+          suctions,
+          cisterns,
+          cleanCounts,
+          yMops,
+          sweepMopModes
+        }
+      });
+      ty.device.sendMqttMessage(params);
+      return normalResolve(RoomCleanSetEnum.query, params.message.taskId);
+    }
+  };
+};