@ray-js/robot-data-stream 0.0.14 → 0.0.15-beta.2

package/lib/mqtt/createCommonOptions.d.ts

@@ -22,6 +22,8 @@ export interface CreateSetCommonParamsInput {
     deviceId: string;
     /** 请求类型 */
     reqType: string;
+    /** 是否是局域网 */
+    isLocalOnLine: boolean;
     /** 消息体（可选） */
     message?: Partial<MqttMessage>;
     /** 版本号（可选，默认为 1.0.0） */
@@ -36,7 +38,7 @@ export interface CreateSetCommonParamsOutput {
     /** 设备ID */
     deviceId: string;
     /** 消息体 */
-    message: MqttMessage;
+    message: MqttMessage | string;
     /** 选项 */
     options: MqttOptions;
     /** 协议号 */
@@ -62,4 +64,4 @@ export interface CreateSetCommonParamsOutput {
  * });
  * ```
  */
-export declare const createSetCommonParams: ({ deviceId, reqType, message, version, options, }: CreateSetCommonParamsInput) => CreateSetCommonParamsOutput;
+export declare const createSetCommonParams: ({ deviceId, reqType, isLocalOnLine, message, version, options, }: CreateSetCommonParamsInput) => CreateSetCommonParamsOutput;

package/lib/mqtt/createCommonOptions.js

@@ -46,18 +46,23 @@ export const createSetCommonParams = _ref => {
   let {
     deviceId,
     reqType,
+    isLocalOnLine,
     message = {},
     version = DEFAULT_VERSION,
     options = {}
   } = _ref;
   const taskId = Date.now();
+  const messageData = _objectSpread({
+    reqType,
+    version,
+    taskId: `${taskId}`
+  }, message);
   return {
     deviceId,
-    message: _objectSpread({
-      reqType,
-      version,
-      taskId: `${taskId}`
-    }, message),
+    message: !isLocalOnLine ? messageData : JSON.stringify({
+      data: messageData,
+      reqType
+    }),
     options,
     protocol: ProtocolEnum.appToRobot
   };

package/lib/mqtt/hooks/useStructuredMessage.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 统一的 MQTT 消息发送 Hook
+ * 提供统一的 sendMqttMessage 方法，自动从 Context 获取 devId 和配置
+ */
+export declare const useStructuredMessage: () => {
+    sendStructuredMessage: <T extends z.infer<any>>(reqType: string, message: Record<string, any> | undefined, resolve: (value: T) => void, reject: (reason?: any) => void, responseType?: string) => void;
+};
+/**
+ * 错误处理工具函数
+ * @param error 错误对象
+ * @param defaultMessage 默认错误消息
+ * @returns Error 对象
+ */
+export declare const handleMqttError: (error: unknown, defaultMessage: string) => Error;

package/lib/mqtt/hooks/useStructuredMessage.js

@@ -0,0 +1,131 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import { getDeviceOnlineType, onDeviceOnlineStatusUpdate } from '@ray-js/ray';
+import { isFunction } from 'lodash-es';
+import { useCallback, useEffect, useRef } from 'react';
+import { getBitValue, logger } from '../../utils';
+import { createSetCommonParams } from '../createCommonOptions';
+import { useMqtt } from '../mqttProvider';
+import { normalResolve } from '../promise';
+/**
+ * 统一的 MQTT 消息发送 Hook
+ * 提供统一的 sendMqttMessage 方法，自动从 Context 获取 devId 和配置
+ */
+export const useStructuredMessage = () => {
+  const context = useMqtt();
+  const {
+    devId
+  } = context.devices.common.getDevInfo();
+  const isLocalOnLineRef = useRef(false);
+  const isWifiOnLineRef = useRef(true);
+  const _onDeviceOnlineStatusChange = useCallback(_ref => {
+    let {
+      onlineType
+    } = _ref;
+    // bit 0: WiFi在线
+    const wifiOnline = !!getBitValue(onlineType, 0);
+    // bit 1: 局域网在线
+    const localOnline = !!getBitValue(onlineType, 1);
+    logger('info', {
+      msg: `onDeviceOnlineStatusChange00000: onlineType ==>${onlineType}===>wifiOnline:${wifiOnline}===>localOnline:${localOnline}`
+    });
+    isLocalOnLineRef.current = localOnline;
+    isWifiOnLineRef.current = wifiOnline;
+  }, []);
+  useEffect(() => {
+    if (!devId) return;
+    getDeviceOnlineType({
+      deviceId: devId,
+      success: _onDeviceOnlineStatusChange
+    });
+    onDeviceOnlineStatusUpdate(_onDeviceOnlineStatusChange);
+  }, [_onDeviceOnlineStatusChange, devId]);
+
+  /**
+   * 发送 MQTT 消息
+   * @param reqType 请求类型
+   * @param message 消息体（可选）
+   * @param responseType 响应类型（可选，如果不提供则使用 reqType）
+   * @param resolve Promise 的 resolve 回调
+   * @param reject Promise 的 reject 回调
+   */
+  const sendStructuredMessage = useCallback((reqType, message, resolve, reject, responseType) => {
+    if (!devId) {
+      reject(new Error('devId is required'));
+      return;
+    }
+    // 检查是否使用 MQTT 模式
+    if (!context.useMqtt) {
+      reject(new Error(`Operation ${reqType} requires MQTT mode. Please enable useMqtt in MqttProvider.`));
+      return;
+    }
+    try {
+      var _ty, _ty2;
+      const params = createSetCommonParams({
+        deviceId: devId,
+        reqType,
+        message,
+        isLocalOnLine: isLocalOnLineRef.current
+      });
+
+      // 优先使用局域网通信（LAN）
+      if (isLocalOnLineRef.current && (_ty = ty) !== null && _ty !== void 0 && _ty.device && isFunction(ty.device.publishLanMessage)) {
+        // @ts-ignore - publishLanMessage 可能不存在于类型定义中
+        ty.device.publishLanMessage(_objectSpread(_objectSpread({}, params), {}, {
+          success: () => {
+            logger('info', {
+              msg: `${reqType} LAN message publish success: ${JSON.stringify(params)}`
+            });
+            // 局域网通信成功回调
+          },
+          fail: e => {
+            logger('error', {
+              msg: `${reqType} LAN message publish failed: ${JSON.stringify(e)}`
+            });
+          }
+        }));
+      }
+      // 如果局域网不可用，使用 WiFi MQTT 通信
+      else if (isWifiOnLineRef.current && (_ty2 = ty) !== null && _ty2 !== void 0 && _ty2.device && isFunction(ty.device.sendMqttMessage)) {
+        ty.device.sendMqttMessage(_objectSpread(_objectSpread({}, params), {}, {
+          success: () => {
+            // WiFi MQTT 通信成功回调
+            logger('info', {
+              msg: `${reqType} WiFi MQTT message send success: ${JSON.stringify(params)}`
+            });
+          },
+          fail: e => {
+            logger('error', {
+              msg: `${reqType} MQTT message send failed: ${JSON.stringify(e)}`
+            });
+          }
+        }));
+      }
+      // 如果两种通信方式都不可用，抛出错误
+      else {
+        reject(new Error(`No available communication method. LAN online: ${isLocalOnLineRef.current}, WiFi online: ${isWifiOnLineRef.current}`));
+        return;
+      }
+      // 如果指定了响应类型，使用响应类型；否则使用请求类型
+
+      normalResolve(responseType || reqType, resolve, reject);
+    } catch (error) {
+      reject(error);
+    }
+  }, [devId, context.useMqtt]);
+  return {
+    sendStructuredMessage
+  };
+};
+
+/**
+ * 错误处理工具函数
+ * @param error 错误对象
+ * @param defaultMessage 默认错误消息
+ * @returns Error 对象
+ */
+export const handleMqttError = (error, defaultMessage) => {
+  if (error instanceof Error) {
+    return error;
+  }
+  return new Error(defaultMessage);
+};

package/lib/mqtt/mqttProvider.d.ts

@@ -1,4 +1,5 @@
 import React from 'react';
+import { MqttError } from './promise';
 export interface MqttContextValue {
     useMqtt: boolean;
     commandVersion: '0' | '1';
@@ -19,15 +20,32 @@ export interface MqttContextValue {
     };
 }
 export declare const SingletonContext: React.Context<MqttContextValue | null>;
+export type MqttErrorHandler = (error: MqttError) => void;
 export interface MqttProviderProps {
     children: React.ReactNode;
     useMqtt: boolean;
     commandVersion: '0' | '1';
     devices: MqttContextValue['devices'];
     onMqttReady?: () => void;
+    /**
+     * 可选的错误处理回调
+     * 当 MQTT 请求发生未捕获的错误时（如超时、请求失败等），会调用此回调
+     *
+     * @example
+     * ```typescript
+     * <MqttProvider
+     *   onError={(error) => {
+     *     console.error('MQTT Error:', error);
+     *     // 可以发送到错误监控服务
+     *   }}
+     *   ...
+     * />
+     * ```
+     */
+    onError?: MqttErrorHandler;
 }
 export declare function useMqtt(): MqttContextValue;
-export declare function MqttProvider({ children, useMqtt, commandVersion, devices, onMqttReady, }: MqttProviderProps): React.JSX.Element;
+export declare function MqttProvider({ children, useMqtt, commandVersion, devices, onError, onMqttReady, }: MqttProviderProps): React.JSX.Element;
 export declare namespace MqttProvider {
     var defaultProps: {
         onMqttReady: undefined;

package/lib/mqtt/mqttProvider.js

@@ -1,14 +1,19 @@
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
-import { get, isNil } from 'lodash-es';
+import { registerMQTTProtocolListener } from '@ray-js/ray';
+import { get, isFunction, isNil } from 'lodash-es';
 import React, { createContext, useCallback, useContext, useEffect, useMemo, useRef } from 'react';
 import { emitter } from '../utils';
+import { setUnhandledRejectionHandler } from './promise';
 import { ProtocolEnum } from './type';
+import log4js from '@ray-js/log4js';
 
 // Context 类型定义
 
 // 创建一个Context
 export const SingletonContext = /*#__PURE__*/createContext(null);
 
+// MQTT 错误处理函数类型
+
 // MqttProvider Props 类型定义
 
 // MQTT 消息数据类型
@@ -27,13 +32,19 @@ export function MqttProvider(_ref) {
     useMqtt,
     commandVersion,
     devices,
+    onError,
     onMqttReady
   } = _ref;
+  // const [isLocalOnLine, setIsLocalOnLine] = useState(false);
+  // const [isWifiOnLine, setIsWifiOnLine] = useState(true);
+
   // 使用 useMemo 创建实例，确保只在依赖项变化时重新创建
   const instance = useMemo(() => ({
     useMqtt,
     commandVersion,
     devices
+    // isLocalOnLine,
+    // isWifiOnLine,
   }), [useMqtt, commandVersion, devices]);
 
   // 使用 ref 存储设备 ID 和初始化状态，避免重复初始化
@@ -67,9 +78,46 @@ export function MqttProvider(_ref) {
     });
     emitter.emit(reqType, responseData);
   }, []);
+  const onSocketMessageReceived = useCallback(event => {
+    const {
+      message
+    } = event || {};
+    log4js.info('onSocketMessageReceived======>', {
+      msg: JSON.stringify(message)
+    });
+    if (message !== null && message !== void 0 && message.data && message !== null && message !== void 0 && message.reqType) {
+      emitter.emit(message.reqType, message.data);
+    }
+  }, []);
+
+  // 设置全局错误处理器（不依赖 window，适用于小程序环境）
+  useEffect(() => {
+    if (onError) {
+      // 设置全局错误处理器
+      setUnhandledRejectionHandler(error => {
+        try {
+          onError(error);
+        } catch (handlerError) {
+          // 避免错误处理器本身抛出错误导致无限循环
+          console.error('Error in MQTT error handler:', handlerError);
+        }
+      });
+    } else {
+      // 如果没有提供错误处理器，设置默认处理器（记录警告）
+      setUnhandledRejectionHandler(error => {
+        console.warn(`[MQTT] Unhandled rejection for ${error.reqType}:`, error.message);
+      });
+    }
+
+    // 清理函数：组件卸载时移除全局处理器
+    return () => {
+      setUnhandledRejectionHandler(null);
+    };
+  }, [onError]);
 
   // 初始化 MQTT 监听器（只执行一次）
   useEffect(() => {
+    var _ty;
     // 防止重复初始化
     if (isInitializedRef.current) return;
 
@@ -88,10 +136,11 @@ export function MqttProvider(_ref) {
     }
 
     // 注册 MQTT 协议监听器
-    ty.device.registerMQTTProtocolListener({
+    registerMQTTProtocolListener({
       protocol: ProtocolEnum.robotToApp,
       success: () => {
         console.log('注册mqtt成功');
+        onMqttReady === null || onMqttReady === void 0 || onMqttReady();
       },
       fail: error => {
         console.error('注册mqtt失败:', error);
@@ -105,14 +154,26 @@ export function MqttProvider(_ref) {
       }
     });
 
+    // 注册设备服务监听器（如果方法存在）
+    // @ts-ignore - registerDeviceServiceListener 可能不存在于类型定义中
+    if ((_ty = ty) !== null && _ty !== void 0 && _ty.device && isFunction(ty.device.registerDeviceServiceListener)) {
+      var _ty2;
+      // @ts-ignore
+      ty.device.registerDeviceServiceListener({
+        success: event => {
+          console.log(event, '++++++++++2222++++++');
+        },
+        fail: e => {
+          console.log(e);
+        }
+      });
+      // 注册 Socket 消息接收监听器
+      (_ty2 = ty) === null || _ty2 === void 0 || (_ty2 = _ty2.device) === null || _ty2 === void 0 || _ty2.onSocketMessageReceived(onSocketMessageReceived);
+    }
+
     // 标记为已初始化
     isInitializedRef.current = true;
-
-    // 调用 onMqttReady 回调，通知业务侧 MQTT 监听器已准备就绪
-    if (onMqttReadyRef.current) {
-      onMqttReadyRef.current();
-    }
-  }, [devices, onMqttMessageReceived]);
+  }, [devices, onMqttMessageReceived, onMqttReady]);
 
   // 将实例作为 value 传递给消费组件
   return /*#__PURE__*/React.createElement(SingletonContext.Provider, {

package/lib/mqtt/promise.d.ts

@@ -1,4 +1,22 @@
-declare class MyError extends Error {
+/**
+ * 设置全局未处理的 rejection 处理器
+ *
+ * @param handler 处理函数，接收 MqttError 作为参数
+ *
+ * @example
+ * ```typescript
+ * setUnhandledRejectionHandler((error) => {
+ *   console.error('Unhandled MQTT error:', error);
+ *   // 可以发送到错误监控服务
+ * });
+ * ```
+ */
+export declare function setUnhandledRejectionHandler(handler: ((error: MqttError) => void) | null): void;
+/**
+ * MQTT 请求错误类
+ * 包含错误代码和请求类型信息
+ */
+export declare class MqttError extends Error {
     errCode: number;
     reqType: string;
     constructor(message: string, { errCode, reqType }: {
@@ -6,8 +24,43 @@ declare class MyError extends Error {
         reqType: string;
     });
 }
+/**
+ * MQTT 响应消息类型（兼容 MQTT 响应格式）
+ */
+export interface MqttResponseMessage {
+    taskId: string | number;
+    errCode?: number;
+    data?: any;
+    reqType?: string;
+    version?: string;
+    success?: boolean;
+    [key: string]: any;
+}
+/**
+ * Promise 扩展类型，支持手动拒绝
+ */
 export type PromiseWithRejection = Promise<any> & {
-    reject: (reason?: MyError) => void;
+    reject: (reason?: MqttError) => void;
 };
-export declare function normalResolve(reqType: string, taskId: string): PromiseWithRejection;
-export {};
+/**
+ * 创建 MQTT 请求的 Promise，监听响应消息
+ *
+ * ⚠️ 注意：此函数不再使用 taskId 进行匹配，只要接收到对应 reqType 的响应就认为匹配
+ * ⚠️ 风险：如果同时发起多个相同 reqType 的请求，可能会匹配到错误的响应
+ * ⚠️ 建议：确保业务上不会同时发起多个相同类型的请求
+ *
+ * @param reqType 请求类型，用于匹配响应消息
+ * @param taskId 任务ID（已废弃，保留参数以保持向后兼容）
+ * @param resolve Promise 的 resolve 回调
+ * @param reject Promise 的 reject 回调
+ * @param timeout 超时时间（毫秒），默认 10 秒
+ *
+ * @example
+ * ```typescript
+ * return new Promise((resolve, reject) => {
+ *   normalResolve('carpetQry', '', resolve, reject);
+ * });
+ * ```
+ */
+export declare function normalResolve(reqType: string, resolve: (value: any) => void, reject: (reason?: any) => void, timeout?: number): void;
+export type MyError = MqttError;

package/lib/mqtt/promise.js

@@ -1,54 +1,133 @@
-import { emitter } from '../utils';
+import { emitter, logger } from '../utils';
 
-// 1. 定义 MyError 类型
-class MyError extends Error {
+/**
+ * MQTT 请求超时时间（毫秒）
+ * 默认 10 秒
+ */
+const DEFAULT_TIMEOUT = 10 * 1000;
+
+/**
+ * 全局未处理的 rejection 处理器
+ * 当 Promise 被 reject 但没有被 catch 时调用
+ */
+let globalUnhandledRejectionHandler = null;
+
+/**
+ * 设置全局未处理的 rejection 处理器
+ *
+ * @param handler 处理函数，接收 MqttError 作为参数
+ *
+ * @example
+ * ```typescript
+ * setUnhandledRejectionHandler((error) => {
+ *   console.error('Unhandled MQTT error:', error);
+ *   // 可以发送到错误监控服务
+ * });
+ * ```
+ */
+export function setUnhandledRejectionHandler(handler) {
+  globalUnhandledRejectionHandler = handler;
+}
+
+/**
+ * MQTT 请求错误类
+ * 包含错误代码和请求类型信息
+ */
+export class MqttError extends Error {
   constructor(message, _ref) {
     let {
       errCode,
       reqType
     } = _ref;
     super(message);
+    this.name = 'MqttError';
     this.errCode = errCode;
     this.reqType = reqType;
+
+    // 确保错误堆栈正确
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, MqttError);
+    }
   }
 }
 
-// 2. 定义 Message 类型（兼容 MQTT 响应格式）
+/**
+ * MQTT 响应消息类型（兼容 MQTT 响应格式）
+ */
+
+/**
+ * Promise 扩展类型，支持手动拒绝
+ */
 
-// 3. 定义 PromiseWithRejection 类型
+/**
+ * 创建 MQTT 请求的 Promise，监听响应消息
+ *
+ * ⚠️ 注意：此函数不再使用 taskId 进行匹配，只要接收到对应 reqType 的响应就认为匹配
+ * ⚠️ 风险：如果同时发起多个相同 reqType 的请求，可能会匹配到错误的响应
+ * ⚠️ 建议：确保业务上不会同时发起多个相同类型的请求
+ *
+ * @param reqType 请求类型，用于匹配响应消息
+ * @param taskId 任务ID（已废弃，保留参数以保持向后兼容）
+ * @param resolve Promise 的 resolve 回调
+ * @param reject Promise 的 reject 回调
+ * @param timeout 超时时间（毫秒），默认 10 秒
+ *
+ * @example
+ * ```typescript
+ * return new Promise((resolve, reject) => {
+ *   normalResolve('carpetQry', '', resolve, reject);
+ * });
+ * ```
+ */
+export function normalResolve(reqType, resolve, reject) {
+  let timeout = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : DEFAULT_TIMEOUT;
+  let isResolved = false;
 
-// 4. 定义 normalResolve 函数
-export function normalResolve(reqType, taskId) {
-  return new Promise((resolve, reject) => {
-    // 设置超时定时器
-    const timer = setTimeout(() => {
-      reject(new MyError(`${taskId} ${reqType} Request timed out `, {
+  // 设置超时定时器
+  const timer = setTimeout(() => {
+    if (!isResolved) {
+      isResolved = true;
+      // 确保在超时时也移除监听器
+      emitter.off(reqType, handle);
+      reject(new MqttError(`${reqType} Request timed out`, {
         errCode: -1,
         reqType
       }));
-    }, 10 * 1000);
-    const handle = message => {
-      var _message$errCode;
-      // 通过 taskId 匹配响应
-      if (`${message.taskId}` !== `${taskId}`) {
-        return;
-      }
-      clearTimeout(timer);
-
-      // 优先使用 errCode，如果没有则使用 success 字段判断
-      const errCode = (_message$errCode = message.errCode) !== null && _message$errCode !== void 0 ? _message$errCode : message.success === false ? -1 : 0;
-      if (errCode === 0) {
-        resolve(message);
-      } else {
-        reject(new MyError('Request failed', {
-          errCode,
-          reqType
-        }));
-      }
-      emitter.off(reqType, handle);
-    };
+    }
+  }, timeout);
+  const handle = message => {
+    var _response$errCode;
+    const response = typeof message.data === 'object' ? message.data : message;
+
+    // 如果已经处理过，直接返回（避免重复处理）
+    if (isResolved) {
+      return;
+    }
+
+    // 标记为已处理（防止其他监听器处理）
+    isResolved = true;
+    clearTimeout(timer);
+    logger('info', {
+      msg: `${reqType} normalResolve: response ==>${JSON.stringify(response)}`
+    });
+
+    // 移除监听器（使用函数引用确保移除正确的监听器）
+    emitter.off(reqType, handle);
+
+    // 优先使用 errCode，如果没有则使用 success 字段判断
+    const errCode = (_response$errCode = response.errCode) !== null && _response$errCode !== void 0 ? _response$errCode : response.success === false ? -1 : 0;
+    if (errCode === 0) {
+      resolve(response);
+    } else {
+      reject(new MqttError('Request failed', {
+        errCode,
+        reqType
+      }));
+    }
+  };
+
+  // 监听指定类型的消息
+  emitter.on(reqType, handle);
+}
 
-    // 监听指定类型的消息
-    emitter.on(reqType, handle);
-  });
-}
+// 为了向后兼容，导出旧的类型别名

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

@@ -0,0 +1,49 @@
+import * as z from 'zod/mini';
+import { pointsSchema, roomIdSchema, originSchema } from './protocols/partDivisionProtocol';
+export declare const ProtocolSchemas: {
+    query_carpet: any;
+    add_carpet: any;
+    update_carpet: any;
+    delete_carpet: any;
+    set_carpet: any;
+    set_schedule: any;
+    request_schedule: any;
+    set_zone_clean: any;
+    set_wifi_map: any;
+    set_voice: any;
+    set_virtual_wall: any;
+    set_virtual_area: any;
+    set_spot_clean: any;
+    set_select_room_clean: any;
+    set_quiet_hours: any;
+    set_password: any;
+    check_password: any;
+    set_part_merge: any;
+    delete_history_map: any;
+    save_map: any;
+    change_current_map: any;
+    request_furniture_list: any;
+    set_furniture_model: any;
+    set_device_model: any;
+    set_carpet_clean: any;
+    set_room_property: any;
+};
+export type ProtocolTypes = {
+    [K in keyof typeof ProtocolSchemas]: z.infer<(typeof ProtocolSchemas)[K]>;
+};
+export declare class MiniProtocolValidator {
+    validate<T extends keyof ProtocolTypes>(protocol: T, data: unknown): ProtocolTypes[T];
+    /**
+     * 验证 set_part_division 的三个独立参数
+     * @param points 分隔点数组
+     * @param roomId 房间ID（可以是 int 或 string）
+     * @param origin 地图原点坐标
+     * @returns 验证后的数据对象
+     */
+    validateSetPartDivision(points: unknown, roomId: unknown, origin: unknown): {
+        points: z.infer<typeof pointsSchema>;
+        roomId: z.infer<typeof roomIdSchema>;
+        origin: z.infer<typeof originSchema>;
+    };
+}
+export declare const validator: MiniProtocolValidator;