@ray-js/robot-data-stream 0.0.13-beta-5 → 0.0.13-beta-7

package/lib/mqtt/type/index.d.ts

@@ -6,6 +6,15 @@ export interface BaseResponse {
     version: string;
     taskId: string;
 }
+/**
+ * MQTT 协议号枚举
+ */
+export declare enum ProtocolEnum {
+    /** 面板下发 */
+    appToRobot = 64,
+    /** 设备上报 */
+    robotToApp = 65
+}
 export declare enum PasswordEnum {
     query = "passwordQry",
     set = "passwordSet",
@@ -13,6 +22,11 @@ export declare enum PasswordEnum {
     check = "passwordCheck",
     checkRst = "passwordCheckRst"
 }
+export declare enum WifiMapEnum {
+    query = "WifiMapQry",
+    set = "WifiMapSet",
+    rst = "WifiMapRst"
+}
 export type RoomPreference = {
     suctions?: string[];
     cisterns?: string[];

package/lib/mqtt/type/index.js

@@ -1,6 +1,14 @@
 export * from './requestType';
 // 设备接口响应的统一标准结构
 
+/**
+ * MQTT 协议号枚举
+ */
+export let ProtocolEnum = /*#__PURE__*/function (ProtocolEnum) {
+  ProtocolEnum[ProtocolEnum["appToRobot"] = 64] = "appToRobot";
+  ProtocolEnum[ProtocolEnum["robotToApp"] = 65] = "robotToApp";
+  return ProtocolEnum;
+}({});
 export let PasswordEnum = /*#__PURE__*/function (PasswordEnum) {
   PasswordEnum["query"] = "passwordQry";
   PasswordEnum["set"] = "passwordSet";
@@ -8,4 +16,10 @@ export let PasswordEnum = /*#__PURE__*/function (PasswordEnum) {
   PasswordEnum["check"] = "passwordCheck";
   PasswordEnum["checkRst"] = "passwordCheckRst";
   return PasswordEnum;
+}({});
+export let WifiMapEnum = /*#__PURE__*/function (WifiMapEnum) {
+  WifiMapEnum["query"] = "WifiMapQry";
+  WifiMapEnum["set"] = "WifiMapSet";
+  WifiMapEnum["rst"] = "WifiMapRst";
+  return WifiMapEnum;
 }({});

package/lib/mqtt/type/requestType.d.ts

@@ -21,6 +21,11 @@ export declare enum PasswordEnum {
     check = "passwordCheck",
     checkRst = "passwordCheckRst"
 }
+export declare enum WifiMapEnum {
+    query = "WifiMapQry",
+    set = "WifiMapSet",
+    rst = "WifiMapRst"
+}
 export declare enum RoomPropertyEnum {
     set = "roomPropertySet",
     query = "roomPropertyQry"
@@ -65,3 +70,6 @@ export declare enum UseMapEnum {
     query = "useMapRst",
     set = "useMapSet"
 }
+export declare enum DevInfoEnum {
+    query = "devInfoQry"
+}

package/lib/mqtt/type/requestType.js

@@ -32,6 +32,12 @@ export let PasswordEnum = /*#__PURE__*/function (PasswordEnum) {
   PasswordEnum["checkRst"] = "passwordCheckRst";
   return PasswordEnum;
 }({});
+export let WifiMapEnum = /*#__PURE__*/function (WifiMapEnum) {
+  WifiMapEnum["query"] = "WifiMapQry";
+  WifiMapEnum["set"] = "WifiMapSet";
+  WifiMapEnum["rst"] = "WifiMapRst";
+  return WifiMapEnum;
+}({});
 export let RoomPropertyEnum = /*#__PURE__*/function (RoomPropertyEnum) {
   RoomPropertyEnum["set"] = "roomPropertySet";
   RoomPropertyEnum["query"] = "roomPropertyQry";
@@ -98,4 +104,8 @@ export let UseMapEnum = /*#__PURE__*/function (UseMapEnum) {
   UseMapEnum["query"] = "useMapRst";
   UseMapEnum["set"] = "useMapSet";
   return UseMapEnum;
+}({});
+export let DevInfoEnum = /*#__PURE__*/function (DevInfoEnum) {
+  DevInfoEnum["query"] = "devInfoQry";
+  return DevInfoEnum;
 }({});

package/lib/mqtt/useDevInfo.d.ts

@@ -1,12 +1,7 @@
-interface DevInfoResponse {
-    reqType?: string;
-    version?: string;
+import { BaseResponse } from './type';
+export interface DevInfoResponse extends BaseResponse {
     info: string;
-    success?: boolean;
-    errCode?: number;
-    taskId?: string;
 }
 export declare const useDevInfo: (devId: string) => {
     requestDevInfo: () => Promise<DevInfoResponse>;
 };
-export {};

package/lib/mqtt/useDevInfo.js

@@ -1,12 +1,12 @@
+import { hexToUriDecodedString } from '@ray-js/robot-protocol';
 import { useContext } from 'react';
 import { createSetCommonParams } from './createCommonOptions';
 import { SingletonContext } from './mqttProvider';
 import { normalResolve } from './promise';
-import { hexToUriDecodedString } from '@ray-js/robot-protocol';
-var DevInfoEnum = /*#__PURE__*/function (DevInfoEnum) {
-  DevInfoEnum["query"] = "devInfoQry";
-  return DevInfoEnum;
-}(DevInfoEnum || {});
+import { DevInfoEnum } from './type';
+
+// 设备信息响应类型
+
 // 请求设备信息
 export const useDevInfo = devId => {
   const {
@@ -27,10 +27,26 @@ export const useDevInfo = devId => {
         } = params.message;
         return normalResolve(DevInfoEnum.query, taskId);
       }
-      const dpDevInfo = devices.common.model.props.device_info;
-      return Promise.resolve({
-        info: hexToUriDecodedString(dpDevInfo)
-      });
+
+      // 非 MQTT 模式：从设备属性中获取设备信息
+      try {
+        var _devices$common$model;
+        const dpDevInfo = (_devices$common$model = devices.common.model.props) === null || _devices$common$model === void 0 ? void 0 : _devices$common$model.device_info;
+        if (!dpDevInfo) {
+          return Promise.reject(new Error('Device info is not available in device properties'));
+        }
+        const info = hexToUriDecodedString(dpDevInfo);
+        return Promise.resolve({
+          info,
+          success: true,
+          errCode: 0,
+          reqType: DevInfoEnum.query,
+          version: '1.0.0',
+          taskId: `${Date.now()}`
+        });
+      } catch (error) {
+        return Promise.reject(error instanceof Error ? error : new Error('Failed to get device info from device properties'));
+      }
     }
   };
 };

package/lib/mqtt/useHistoryMap.d.ts

@@ -1,26 +1,18 @@
-type TDeleteHistoryMap = (mapId: number) => Promise<{
-    success: boolean;
-    errCode: number;
-    reqType: string;
-    version: string;
-    taskId: string;
-}>;
-type TChangeCurrentMap = (mapId: number, url: string) => Promise<{
-    success: boolean;
-    errCode: number;
-    reqType: string;
+import { BaseResponse, DeleteMapEnum, SaveCurrentMapEnum, UseMapEnum } from './type';
+interface DeleteMapResponse extends BaseResponse {
+    reqType: DeleteMapEnum.rst;
+}
+interface SaveMapResponse extends BaseResponse {
+    reqType: SaveCurrentMapEnum.query;
     mapId: number;
-    version: string;
-    taskId: string;
-}>;
-type TSaveMap = () => Promise<{
-    success: boolean;
-    errCode: number;
-    reqType: string;
+}
+interface UseMapResponse extends BaseResponse {
+    reqType: UseMapEnum.query;
     mapId: number;
-    version: string;
-    taskId: string;
-} | void>;
+}
+type TDeleteHistoryMap = (mapId: number) => Promise<DeleteMapResponse>;
+type TSaveMap = () => Promise<SaveMapResponse>;
+type TChangeCurrentMap = (mapId: number, url: string) => Promise<UseMapResponse>;
 /**
  * 自定义 Hook，用于管理历史地图
  * @param devId 设备ID

package/lib/mqtt/useHistoryMap.js

@@ -6,8 +6,16 @@ import { DeleteMapEnum, SaveCurrentMapEnum, UseMapEnum } from './type';
 import { SingletonContext } from './mqttProvider';
 import { encodeDeleteMap0x2c, encodeSaveMap0x2a, encodeUseMap0x2e } from '@ray-js/robot-protocol';
 
+// 删除历史地图响应类型
+
+// 保存地图响应类型
+
+// 更改当前地图响应类型
+
 // 删除历史地图函数类型定义
 
+// 保存当前地图函数类型定义
+
 // 更改当前使用的地图函数类型定义
 
 /**
@@ -18,32 +26,36 @@ import { encodeDeleteMap0x2c, encodeSaveMap0x2a, encodeUseMap0x2e } from '@ray-j
 export const useHistoryMap = devId => {
   const {
     useMqtt,
-    devices
+    devices,
+    commandVersion
   } = useContext(SingletonContext);
+
   /**
    * 删除历史地图
    * @param mapId 地图ID
-   * @returns Promise<{ success: boolean; errCode: number; reqType: string; version: string; taskId: string; }> 响应结果
+   * @returns Promise<DeleteMapResponse> 响应结果
    */
 
   /**
    * 保存当前地图
-   * @returns Promise<void> 响应结果
+   * @returns Promise<SaveMapResponse> 响应结果
    */
 
   /**
    * 更改当前使用的地图
    * @param mapId 地图ID
    * @param url 地图URL
-   * @returns Promise<{ success: boolean; errCode: number; reqType: string; mapId: number; version: string; taskId: string; }> 响应结果
+   * @returns Promise<UseMapResponse> 响应结果
    */
 
   return {
     deleteHistoryMap: async mapId => {
+      // 参数验证
+      if (!mapId || typeof mapId !== 'number') {
+        throw new Error('mapId is required and must be a number');
+      }
       try {
-        if (!mapId) {
-          return Promise.reject(new Error('mapId is required'));
-        }
+        // 先删除地图文件
         await deleteMultipleMapFile(mapId, devId);
         if (useMqtt) {
           const params = createSetCommonParams({
@@ -59,28 +71,41 @@ export const useHistoryMap = devId => {
           } = params.message;
           return normalResolve(DeleteMapEnum.rst, taskId);
         }
+
+        // 非 MQTT 模式：使用命令传输
         const command = encodeDeleteMap0x2c({
           id: mapId
         });
         devices.common.model.actions.command_trans.set(command);
-        return Promise.resolve();
-      } catch (err) {
-        return Promise.reject(err);
+        return Promise.resolve({
+          success: true,
+          errCode: 0,
+          reqType: DeleteMapEnum.rst,
+          version: commandVersion,
+          taskId: `${Date.now()}`
+        });
+      } catch (error) {
+        throw error instanceof Error ? error : new Error('Failed to delete history map');
       }
     },
     changeCurrentMap: async (mapId, url) => {
+      // 参数验证
+      if (!mapId || typeof mapId !== 'number') {
+        throw new Error('mapId is required and must be a number');
+      }
+      if (!url || typeof url !== 'string') {
+        throw new Error('url is required and must be a string');
+      }
       try {
         if (useMqtt) {
-          const sendData = {
-            reqType: UseMapEnum.set,
-            mapId,
-            url,
-            urlLen: url.length
-          };
           const params = createSetCommonParams({
             deviceId: devId,
             reqType: UseMapEnum.set,
-            message: sendData
+            message: {
+              mapId,
+              url,
+              urlLen: url.length // URL 长度
+            }
           });
           ty.device.sendMqttMessage(params);
           const {
@@ -88,31 +113,56 @@ export const useHistoryMap = devId => {
           } = params.message;
           return normalResolve(UseMapEnum.query, taskId);
         }
+
+        // 非 MQTT 模式：使用命令传输
         const command = encodeUseMap0x2e({
           mapId,
           url
         });
         devices.common.model.actions.command_trans.set(command);
-        return Promise.resolve();
-      } catch (err) {
-        return Promise.reject(err);
+        return Promise.resolve({
+          success: true,
+          errCode: 0,
+          reqType: UseMapEnum.query,
+          version: commandVersion,
+          taskId: `${Date.now()}`,
+          mapId
+        });
+      } catch (error) {
+        throw error instanceof Error ? error : new Error('Failed to change current map');
       }
     },
     saveMap: () => {
-      if (useMqtt) {
-        const params = createSetCommonParams({
-          deviceId: devId,
-          reqType: SaveCurrentMapEnum.set,
-          message: {
-            oper: 0
-          }
+      try {
+        if (useMqtt) {
+          const params = createSetCommonParams({
+            deviceId: devId,
+            reqType: SaveCurrentMapEnum.set,
+            message: {
+              oper: 0 // 操作类型：0 表示保存
+            }
+          });
+          ty.device.sendMqttMessage(params);
+          const {
+            taskId
+          } = params.message;
+          return normalResolve(SaveCurrentMapEnum.query, taskId);
+        }
+
+        // 非 MQTT 模式：使用命令传输
+        const command = encodeSaveMap0x2a(1);
+        devices.common.model.actions.command_trans.set(command);
+        return Promise.resolve({
+          success: true,
+          errCode: 0,
+          reqType: SaveCurrentMapEnum.query,
+          version: commandVersion,
+          taskId: `${Date.now()}`,
+          mapId: 0 // 非 MQTT 模式下无法获取 mapId
         });
-        ty.device.sendMqttMessage(params);
-        return normalResolve(SaveCurrentMapEnum.query, params.message.taskId);
+      } catch (error) {
+        throw error instanceof Error ? error : new Error('Failed to save current map');
       }
-      const command = encodeSaveMap0x2a(1);
-      devices.common.model.actions.command_trans.set(command);
-      return Promise.resolve();
     }
   };
 };

package/lib/mqtt/usePartDivision.d.ts

@@ -1,11 +1,9 @@
 import { Point } from '../utils';
-type TSetPartDivision = (points: Point[], roomId: number, origin: Point) => Promise<{
-    success: boolean;
-    errCode: number;
-    reqType: string;
-    version: string;
-    taskId: string;
-} | void>;
+import { BaseResponse, PartDivisionEnum } from './type';
+interface PartDivisionResponse extends BaseResponse {
+    reqType: PartDivisionEnum.query;
+}
+type TSetPartDivision = (points: Point[], roomId: number, origin: Point) => Promise<PartDivisionResponse>;
 /**
  * 自定义 Hook，用于房间分隔
  * @param devId 设备ID

package/lib/mqtt/usePartDivision.js

@@ -7,6 +7,8 @@ import { PartDivisionEnum } from './type';
 import { SingletonContext } from './mqttProvider';
 import { encodePartitionDivision0x1c } from '@ray-js/robot-protocol';
 
+// 房间分隔响应类型
+
 // 设置房间分隔函数类型定义
 
 /**
@@ -24,38 +26,61 @@ export const usePartDivision = devId => {
   /**
    * 设置房间分隔
    * @param points 分隔点数组，SDK方法抛出来的坐标直接传入即可
-   * @param roomId 房间ID,当前要分隔的房间
+   * @param roomId 房间ID，当前要分隔的房间
    * @param origin 地图原点坐标
-   * @returns Promise<Response> 响应结果
+   * @returns Promise<PartDivisionResponse> 响应结果
    */
 
   return {
     setPartDivision: (points, roomId, origin) => {
-      if (useMqtt) {
-        try {
+      // 参数验证
+      if (!Array.isArray(points) || points.length === 0) {
+        throw new Error('points is required and must be a non-empty array');
+      }
+      if (typeof roomId !== 'number' || isNaN(roomId)) {
+        throw new Error('roomId is required and must be a valid number');
+      }
+      if (!origin || typeof origin.x !== 'number' || typeof origin.y !== 'number') {
+        throw new Error('origin is required and must be a valid Point object with x and y properties');
+      }
+      try {
+        if (useMqtt) {
+          // 将点数组转换为字符串格式
           const pointStr = pointsToString(points, origin);
           const params = createSetCommonParams({
             deviceId: devId,
             reqType: PartDivisionEnum.set,
             message: {
               lines: [pointStr],
-              ids: [roomId]
+              // 分隔线数组
+              ids: [roomId] // 房间ID数组
             }
           });
           ty.device.sendMqttMessage(params);
-          return normalResolve(PartDivisionEnum.query, params.message.taskId);
-        } catch (e) {
-          throw new Error('房间分隔失败');
+          const {
+            taskId
+          } = params.message;
+          return normalResolve(PartDivisionEnum.query, taskId);
         }
+
+        // 非 MQTT 模式：使用命令传输
+        const command = encodePartitionDivision0x1c({
+          version: commandVersion,
+          origin,
+          points,
+          roomId
+        });
+        devices.common.model.actions.command_trans.set(command);
+        return Promise.resolve({
+          success: true,
+          errCode: 0,
+          reqType: PartDivisionEnum.query,
+          version: commandVersion,
+          taskId: `${Date.now()}`
+        });
+      } catch (error) {
+        throw error instanceof Error ? error : new Error('Failed to set part division');
       }
-      const command = encodePartitionDivision0x1c({
-        version: commandVersion,
-        origin,
-        points,
-        roomId
-      });
-      devices.common.model.actions.command_trans.set(command);
-      return Promise.resolve();
     }
   };
 };

package/lib/mqtt/usePartMerge.d.ts

@@ -1,10 +1,8 @@
-type TSetPartMerge = (ids: number[]) => Promise<{
-    success: boolean;
-    errCode: number;
-    reqType: string;
-    version: string;
-    taskId: string;
-} | void>;
+import { BaseResponse, PartMergeEnum } from './type';
+interface PartMergeResponse extends BaseResponse {
+    reqType: PartMergeEnum.query;
+}
+type TSetPartMerge = (ids: number[]) => Promise<PartMergeResponse>;
 /**
  * 自定义 Hook，用于分区合并
  * @param devId 设备ID

package/lib/mqtt/usePartMerge.js

@@ -8,6 +8,8 @@ import { PartMergeEnum } from './type';
 import { SingletonContext } from './mqttProvider';
 import { encodePartitionMerge0x1e } from '@ray-js/robot-protocol';
 
+// 分区合并响应类型
+
 // 设置分区合并函数类型定义
 
 /**
@@ -24,34 +26,50 @@ export const usePartMerge = devId => {
   /**
    * 设置分区合并
    * @param ids 要合并的分区ID数组
-   * @returns Promise<Response> 响应结果
+   * @returns Promise<PartMergeResponse> 响应结果
    */
 
   return {
     setPartMerge: ids => {
+      // 参数验证
       if (!ids || ids.length < 2) {
-        return Promise.reject(new Error('ids is required and length must be greater than 1'));
+        throw 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'));
+        throw new Error('ids must be an array of numbers');
       }
-      if (useMqtt) {
-        const params = createSetCommonParams({
-          deviceId: devId,
-          reqType: PartMergeEnum.set,
-          message: {
-            ids
-          }
+      try {
+        if (useMqtt) {
+          const params = createSetCommonParams({
+            deviceId: devId,
+            reqType: PartMergeEnum.set,
+            message: {
+              ids
+            }
+          });
+          ty.device.sendMqttMessage(params);
+          const {
+            taskId
+          } = params.message;
+          return normalResolve(PartMergeEnum.query, taskId);
+        }
+
+        // 非 MQTT 模式：使用命令传输
+        const command = encodePartitionMerge0x1e({
+          version: commandVersion,
+          roomIds: ids
+        });
+        devices.common.model.actions.command_trans.set(command);
+        return Promise.resolve({
+          success: true,
+          errCode: 0,
+          reqType: PartMergeEnum.query,
+          version: commandVersion,
+          taskId: `${Date.now()}`
         });
-        ty.device.sendMqttMessage(params);
-        return normalResolve(PartMergeEnum.query, params.message.taskId);
+      } catch (error) {
+        throw error instanceof Error ? error : new Error('Failed to set part merge');
       }
-      const command = encodePartitionMerge0x1e({
-        version: commandVersion,
-        roomIds: ids
-      });
-      devices.common.model.actions.command_trans.set(command);
-      return Promise.resolve();
     }
   };
 };