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

package/lib/api/sweeperP2p.js

@@ -72,7 +72,7 @@ export class SweeperP2p extends P2pApi {
     this.packetTotalMap = new Map([['map.bin', -1], ['map_structured.bin', -1], ['cleanPath.bin', -1], ['ai.bin', -1], ['aiHD_XXXX_YYYY.bin', -1], ['map.bin.stream', -1], ['map_structured.bin.stream', -1], ['cleanPath.bin.stream', -1], ['ai.bin.stream', -1], ['aiHD_XXXX_YYYY.bin.stream', -1]]);
     this.packetSerialNumberCacheMap = new Map([['map.bin', -1], ['map_structured.bin', -1], ['cleanPath.bin', -1], ['ai.bin', -1], ['aiHD_XXXX_YYYY.bin', -1], ['map.bin.stream', -1], ['map_structured.bin.stream', -1], ['cleanPath.bin.stream', -1], ['ai.bin.stream', -1], ['aiHD_XXXX_YYYY.bin.stream', -1]]);
     this.fileLengthCacheMap = new Map([['map.bin', -1], ['map_structured.bin', -1], ['cleanPath.bin', -1], ['ai.bin', -1], ['aiHD_XXXX_YYYY.bin', -1], ['map.bin.stream', -1], ['map_structured.bin.stream', -1], ['cleanPath.bin.stream', -1], ['ai.bin.stream', -1], ['aiHD_XXXX_YYYY.bin.stream', -1]]);
-    this.packetDataCacheMap = new Map([['map.bin', new Map()], ['map_structured.bin', new Map()], ['cleanPath.bin', new Map()], ['ai.bin', new Map()], ['aiHD_XXXX_YYYY.bin', new Map()], ['map.bin.stream', new Map()], ['map_structured.bin.stream', new Map()], ['cleanPath.bin.stream', new Map()], ['ai.bin.stream', new Map()], ['aiHD_XXXX_YYYY.bin.stream', new Map()]]);
+    this.packetDataCacheMap = new Map([['map.bin', new Map()], ['map_structured.bin', new Map()], ['cleanPath.bin', new Map()], ['ai.bin', new Map()], ['aiHD_XXXX_YYYY.bin', new Map()], ['map.bin.stream', new Map()], ['map_structured.bin.stream', new Map()], ['cleanPath.bin.stream', new Map()], ['wifi_map.bin', new Map()], ['wifi_map.bin.stream', new Map()], ['ai.bin.stream', new Map()], ['aiHD_XXXX_YYYY.bin.stream', new Map()]]);
   }
   setStreamFilePath = () => {
     // this.streamFilePath = this.cacheDir + `/${this.albumName}/${devId}/stream`;

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,17 @@
+/**
+ * 统一的 MQTT 消息发送 Hook
+ * 提供统一的 sendMqttMessage 方法，自动从 Context 获取 devId 和配置
+ */
+export declare const useStructuredMessage: () => {
+    sendStructuredMessage: <T extends {
+        success: boolean;
+        errCode: number;
+        reqType: string;
+        version: string;
+        taskId: string;
+    }>(reqType: string, message: Record<string, any> | undefined, resolve: (value: T) => void, reject: (reason?: any) => void, responseType?: string) => void;
+};
+/**
+ * 错误处理工具函数
+ */
+export declare const handleMqttError: (error: unknown, defaultMessage: string) => Error;

package/lib/mqtt/hooks/useStructuredMessage.js

@@ -0,0 +1,206 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import { getDeviceOnlineType, offDeviceOnlineStatusUpdate, 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';
+// 常量定义
+const COMMUNICATION_CHANNELS = {
+  MQTT: 'mqtt',
+  LAN: 'lan'
+};
+const DEVICE_ONLINE_BITS = {
+  WIFI: 0,
+  LOCAL: 1
+};
+const LOG_LEVEL = {
+  INFO: 'info',
+  ERROR: 'error'
+};
+
+// 类型定义
+
+// 通信方法接口
+
+/**
+ * 统一的 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 handleDeviceOnlineStatusChange = useCallback(_ref => {
+    let {
+      onlineType
+    } = _ref;
+    const wifiOnline = Boolean(getBitValue(onlineType, DEVICE_ONLINE_BITS.WIFI));
+    const localOnline = Boolean(getBitValue(onlineType, DEVICE_ONLINE_BITS.LOCAL));
+    isLocalOnlineRef.current = localOnline;
+    isWifiOnlineRef.current = wifiOnline;
+  }, []);
+
+  // 订阅设备在线状态更新
+  useEffect(() => {
+    if (!devId) return;
+    (() => {
+      getDeviceOnlineType({
+        deviceId: devId,
+        success: handleDeviceOnlineStatusChange
+      });
+    })();
+    onDeviceOnlineStatusUpdate(handleDeviceOnlineStatusChange);
+    return offDeviceOnlineStatusUpdate(handleDeviceOnlineStatusChange);
+  }, [devId, handleDeviceOnlineStatusChange]);
+
+  // MQTT 通信方法
+  const mqttCommunication = {
+    isAvailable: () => {
+      var _ty;
+      return isWifiOnlineRef.current && ((_ty = ty) === null || _ty === void 0 ? void 0 : _ty.device) && isFunction(ty.device.sendMqttMessage);
+    },
+    send: (params, successCallback, failCallback) => {
+      const messageParams = _objectSpread(_objectSpread({}, params), {}, {
+        success: successCallback,
+        fail: failCallback
+      });
+      ty.device.sendMqttMessage(messageParams);
+    }
+  };
+
+  // LAN 通信方法
+  const lanCommunication = {
+    isAvailable: () => {
+      var _ty2;
+      return isLocalOnlineRef.current && ((_ty2 = ty) === null || _ty2 === void 0 ? void 0 : _ty2.device) && isFunction(ty.device.publishLanMessage);
+    },
+    send: (params, successCallback, failCallback) => {
+      const messageParams = _objectSpread(_objectSpread({}, params), {}, {
+        success: successCallback,
+        fail: failCallback
+      });
+      ty.device.publishLanMessage(messageParams);
+    }
+  };
+
+  // 创建消息参数
+  const createMessageParams = (reqType, message, useLocal) => {
+    return createSetCommonParams({
+      deviceId: devId,
+      reqType,
+      message,
+      isLocalOnLine: useLocal
+    });
+  };
+
+  // 记录通信日志
+  const logCommunication = (level, reqType, message, params) => {
+    const baseMessage = `${reqType} ${message}`;
+    const fullMessage = params ? `${baseMessage}: ${JSON.stringify(params)}` : baseMessage;
+    logger(level, {
+      msg: fullMessage
+    });
+  };
+
+  // 通信策略选择器
+  const selectCommunicationMethod = preferredChannel => {
+    const isPreferredMqtt = preferredChannel === COMMUNICATION_CHANNELS.MQTT;
+    const primaryMethod = isPreferredMqtt ? mqttCommunication : lanCommunication;
+    const fallbackMethod = isPreferredMqtt ? lanCommunication : mqttCommunication;
+    const useLocal = isPreferredMqtt ? false : true;
+    if (primaryMethod.isAvailable()) {
+      return {
+        method: primaryMethod,
+        useLocal
+      };
+    }
+    if (fallbackMethod.isAvailable()) {
+      return {
+        method: fallbackMethod,
+        useLocal: !useLocal
+      };
+    }
+    return null;
+  };
+
+  // 处理通信失败
+  const handleCommunicationError = (preferredChannel, reject) => {
+    const errorMessage = preferredChannel === COMMUNICATION_CHANNELS.MQTT ? `操作需要 MQTT 模式，请在 MqttProvider 中启用 useMqtt` : `没有可用的通信方式。局域网在线: ${isLocalOnlineRef.current}, WiFi在线: ${isWifiOnlineRef.current}`;
+    reject(new Error(errorMessage));
+  };
+
+  /**
+   * 发送结构化消息
+   */
+  const sendStructuredMessage = useCallback((reqType, message, resolve, reject, responseType) => {
+    // 参数验证
+    if (!devId) {
+      reject(new Error('设备ID (devId) 为必填项'));
+      return;
+    }
+    if (!context.useMqtt) {
+      reject(new Error(`操作 ${reqType} 需要 MQTT 模式。请在 MqttProvider 中启用 useMqtt。`));
+      return;
+    }
+    try {
+      const {
+        preferredChannel
+      } = context;
+      const selectedMethod = selectCommunicationMethod(preferredChannel);
+      if (!selectedMethod) {
+        handleCommunicationError(preferredChannel, reject);
+        return;
+      }
+      const {
+        method,
+        useLocal
+      } = selectedMethod;
+      const messageParams = createMessageParams(reqType, message, useLocal);
+
+      // 成功回调
+
+      // 失败回调
+
+      // 发送消息
+      method.send(messageParams, () => {
+        const channelName = useLocal ? '局域网' : 'WiFi MQTT';
+        const fallbackSuffix = method === mqttCommunication && preferredChannel === COMMUNICATION_CHANNELS.LAN ? ' (备用)' : '';
+        logCommunication(LOG_LEVEL.INFO, reqType, `${channelName} 消息发送成功${fallbackSuffix}`, messageParams);
+      }, error => {
+        logCommunication(LOG_LEVEL.ERROR, reqType, '消息发送失败', _objectSpread(_objectSpread({}, messageParams), {}, {
+          error: JSON.stringify(error)
+        }));
+      });
+
+      // 处理响应
+
+      normalResolve(responseType || reqType, resolve, reject);
+    } catch (error) {
+      logCommunication(LOG_LEVEL.ERROR, reqType, `发送消息时发生异常: ${error}`);
+      reject(error);
+    }
+  }, [devId, context.useMqtt, context.preferredChannel]);
+  return {
+    sendStructuredMessage
+  };
+};
+
+/**
+ * 错误处理工具函数
+ */
+export const handleMqttError = (error, defaultMessage) => {
+  if (error instanceof Error) {
+    return error;
+  }
+  if (typeof error === 'string') {
+    return new Error(error);
+  }
+  return new Error(defaultMessage);
+};

package/lib/mqtt/mqttProvider.d.ts

@@ -1,7 +1,10 @@
 import React from 'react';
+import { MqttError } from './promise';
+export type CommunicationChannel = 'mqtt' | 'lan';
 export interface MqttContextValue {
     useMqtt: boolean;
     commandVersion: '0' | '1';
+    preferredChannel: CommunicationChannel;
     devices: {
         common: {
             getDevInfo: () => {
@@ -19,15 +22,39 @@ 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'];
+    /**
+     * 优先选择的通信通道
+     * - 'mqtt': 优先使用 MQTT 通道（WiFi MQTT）
+     * - 'lan': 优先使用局域网通道（LAN）
+     * @default 'mqtt'
+     */
+    preferredChannel?: CommunicationChannel;
     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, preferredChannel, onError, onMqttReady, }: MqttProviderProps): React.JSX.Element;
 export declare namespace MqttProvider {
     var defaultProps: {
         onMqttReady: undefined;

package/lib/mqtt/mqttProvider.js

@@ -1,14 +1,21 @@
 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,14 +34,20 @@ export function MqttProvider(_ref) {
     useMqtt,
     commandVersion,
     devices,
+    preferredChannel = 'mqtt',
+    onError,
     onMqttReady
   } = _ref;
+  // const [isLocalOnLine, setIsLocalOnLine] = useState(false);
+  // const [isWifiOnLine, setIsWifiOnLine] = useState(true);
+
   // 使用 useMemo 创建实例，确保只在依赖项变化时重新创建
   const instance = useMemo(() => ({
     useMqtt,
     commandVersion,
+    preferredChannel,
     devices
-  }), [useMqtt, commandVersion, devices]);
+  }), [useMqtt, commandVersion, preferredChannel, devices]);
 
   // 使用 ref 存储设备 ID 和初始化状态，避免重复初始化
   const devIdRef = useRef(null);
@@ -67,9 +80,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 +138,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 +156,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;