ipanel-rnapp-ajb-base 1.0.41 → 1.0.42

package/app/.local_dev/localMode.js

@@ -0,0 +1,3 @@
+// 表示是否开启本地首页聊天模式开发调试模式，默认为true，减少本地开发base的配置工作量。但是后续要在发布的base npm包的postinstall脚本中将该值改为false，从而使得避免影响其他开发同事的本地开发
+// 该配置仅影响base在本地开发环境（不分包APP）下的表现，不影响在测试或生产环境（分包APP）下的表现
+export const LOCAL_DEV_CHAT_MODE = true;

package/app/App.js

@@ -40,7 +40,11 @@ import storage from "./storage";
 
 import { navigationRef } from "./utils/RootNavigation";
 import checkLogin from "./hooks/checkLogin";
-import { getModuleVersionInfo, getUserInfo, delThirdId } from "./api/";
+import {
+  getModuleVersionInfo,
+  getUserInfo,
+  delThirdId,
+} from "./api/ipanelCloudApi";
 import { appReport } from "./utils/common";
 
 // 基础导航页、登录页
@@ -103,6 +107,9 @@ import DeviceAnswerDetailScreen from "./screens/CommonScreens/DeviceAnswerDetail
 // Boss绑定页面
 import BindBossScreen from "./screens/CommonScreens/BossScreen";
 
+// ChatModeScreen专用简化版"我的"页面
+import SimpleProfileScreen from "./screens/ChatModeScreen/components/SimpleProfileScreen";
+
 const Stack = createStackNavigator();
 
 const envVersion = NativeModules?.RNToNativeEmitter?.serverCluster || "alpha";
@@ -229,6 +236,13 @@ const CommonScreens = {
       headerShown: false,
     },
   },
+  SimpleProfileScreen: {
+    component: SimpleProfileScreen,
+    screenOptions: {
+      title: "我的",
+      headerShown: false,
+    },
+  },
 };
 
 // screen分组

package/app/api/ipanelCloudApi.js

@@ -18,8 +18,63 @@ export const ADG_SERVICE = `${config.IPANEL_CLOUD_BASE_ADG_URI}/s/install_ea`;
 
 export const APARTMENT_SERVICE = `${config.IPANEL_CLOUD_BASE_URI}/s/smart_home_manage/admin-api`;
 
-// todo 云端获取token服务：https://ai.baidu.com/ai-doc/SPEECH/Mk38lxpgn
-export const baiduAsr = (cuid, len, speechBase64) => {
+const CLOUDHOMECENTER_URL = `${config.IPANEL_CLOUD_BASE_URI}/s/smart_home/cloudhomecenter`;
+
+// 获取百度ASR token，支持缓存和自动刷新
+export const getBaiduAsrToken = async () => {
+  const BAIDU_ASR_TOKEN_KEY = 'baiduasrtoken';
+  const {storage} = global.base;
+
+  try {
+    const cachedTokenInfo = await storage.get(BAIDU_ASR_TOKEN_KEY);
+    // 减去一个缓冲时间，比如5分钟，提前刷新
+    if (
+      cachedTokenInfo &&
+      cachedTokenInfo.accessToken &&
+      cachedTokenInfo.expiresAt > Date.now() - 5 * 60 * 1000
+    ) {
+      return cachedTokenInfo.accessToken;
+    }
+  } catch (error) {
+    console.error('Get baidu asr token from storage error', error);
+  }
+
+  const result = await request({
+    url: CLOUDHOMECENTER_URL,
+    method: 'POST',
+    data: {
+      path: 'asrproxy/token',
+    },
+  }).catch(err => {
+    console.error('Failed to fetch Baidu ASR token', err);
+  });
+
+  if (result && result.code === 0) {
+    const tokenData = result.result;
+
+    if (tokenData && tokenData.access_token && tokenData.expires_in) {
+      const expiresAt = Date.now() + tokenData.expires_in * 1000; // expires_in是秒，转换为毫秒
+      try {
+        await storage.set(BAIDU_ASR_TOKEN_KEY, {
+          accessToken: tokenData.access_token,
+          expiresAt: expiresAt,
+        });
+      } catch (error) {
+        console.error('Set baidu asr token to storage error', error);
+      }
+      return tokenData.access_token;
+    }
+  }
+  return '';
+};
+
+// 百度ASR语音识别服务，支持动态token获取
+export const baiduAsr = async (cuid, len, speechBase64) => {
+  const token = await getBaiduAsrToken();
+  if (!token) {
+    throw new Error('Failed to obtain Baidu ASR token');
+  }
+
   return request({
     url: "https://vop.baidu.com/pro_api", // 语音识别极速版调用地址
     method: "POST",
@@ -28,8 +83,7 @@ export const baiduAsr = (cuid, len, speechBase64) => {
       rate: 16000,
       dev_pid: 80001,
       channel: 1,
-      token:
-        "24.5298600e65d054e08a1290fcc75f174f.2592000.1691141832.282335-17005893",
+      token: token,
       cuid: cuid,
       len,
       speech: speechBase64, // xxx为 base64（FILE_CONTENT）

package/app/base.js

@@ -385,6 +385,65 @@ global.base.getBundleInfo = (moduleName) => {
   });
 };
 
+/**
+ * 加载包并注册组件的公共函数
+ * @param {Array} packages - 要加载的包数组
+ * @param {Object} options - 配置选项
+ * @param {boolean} options.registerStackScreens - 是否注册StackScreens，默认true
+ * @param {boolean} options.showErrorToast - 是否显示错误Toast，默认true
+ * @param {string} options.errorPrefix - 错误日志前缀，默认为空
+ * @returns {Promise<{success: boolean, components: Array}>} 加载结果
+ */
+global.base.loadAndRegisterPackages = async (packages, options = {}) => {
+  const {
+    registerStackScreens = true,
+    showErrorToast = true,
+    errorPrefix = '',
+  } = options;
+
+  try {
+    // 1. 加载包
+    const loadFlag = await global.base
+      .loadPackages({ packages })
+      .catch((errors) => {
+        console.log(`${errorPrefix}包加载失败:`, JSON.stringify(errors));
+        return false;
+      });
+
+    if (!loadFlag) {
+      if (showErrorToast) {
+        global.toast?.showToast("网络繁忙");
+      }
+      console.log(`${errorPrefix}包加载失败`);
+      return { success: false, components: [] };
+    }
+
+    // 2. 获取远程组件
+    const componentPromises = packages.map((pack) =>
+      global.base.getRemoteComponentByName(pack.moduleName)
+    );
+
+    const components = await Promise.all(componentPromises);
+
+    // 3. 注册组件（如果需要）
+    if (registerStackScreens) {
+      components.forEach((component) => {
+        typeof component?.registerStackScreens === "function" &&
+          component.registerStackScreens();
+      });
+    }
+
+    console.log(`${errorPrefix}包加载和组件注册成功`);
+    return { success: true, components };
+  } catch (error) {
+    console.log(`${errorPrefix}loadAndRegisterPackages失败:`, error);
+    if (showErrorToast) {
+      global.toast?.showToast("加载失败");
+    }
+    return { success: false, components: [] };
+  }
+};
+
 // 动态加载指定模块并注册为独立页面，然后跳转
 global.base.navigateModule = async ({
   operatorId,
@@ -425,20 +484,19 @@ global.base.navigateModule = async ({
 
     const packages = result.data.packages;
 
-    const flag = await global.base
-      .loadPackages({
-        packages,
-      })
-      .catch((errors) => {
-        console.log(JSON.stringify(errors));
-      });
+    // 使用公共函数加载包，但不注册StackScreens（使用特殊的GlobalStackScreen注册）
+    const loadResult = await global.base.loadAndRegisterPackages(packages, {
+      registerStackScreens: false, // navigateModule使用特殊的注册方式
+      showErrorToast: true,
+      errorPrefix: `动态加载${moduleName}`,
+    });
 
-    if (!flag) {
-      global.toast.showToast("网络繁忙");
+    if (!loadResult.success) {
       console.log("网络繁忙");
       return false;
     }
 
+    // 使用navigateModule专用的注册方式
     const registerFlag =
       await global.base.registerRemoteComponentGlobalStackScreen(moduleName, {
         title: packages[0].moduleChineseName,

package/app/hooks/useStreamingText.js

@@ -0,0 +1,222 @@
+import {useState, useRef, useEffect, useCallback} from 'react';
+
+/**
+ * 流式文本状态管理Hook
+ * 专门用于处理智能客服的实时文本流
+ */
+export default function useStreamingText() {
+  const [streamingMessages, setStreamingMessages] = useState(new Map());
+  const streamBufferRef = useRef(new Map());
+  const streamTimerRef = useRef(new Map());
+
+  /**
+   * 更新流式消息内容
+   * @param {string} messageId - 消息ID
+   * @param {string} content - 新的内容
+   * @param {boolean} isComplete - 是否完成
+   */
+  const updateStreamingMessage = useCallback(
+    (messageId, content, isComplete = false) => {
+      setStreamingMessages(prev => {
+        const newMap = new Map(prev);
+        newMap.set(messageId, {
+          content,
+          isComplete,
+          lastUpdate: Date.now(),
+        });
+        return newMap;
+      });
+
+      // 如果消息完成，清理相关的缓冲区和定时器
+      if (isComplete) {
+        streamBufferRef.current.delete(messageId);
+        if (streamTimerRef.current.has(messageId)) {
+          clearTimeout(streamTimerRef.current.get(messageId));
+          streamTimerRef.current.delete(messageId);
+        }
+      }
+    },
+    [],
+  );
+
+  /**
+   * 处理增量文本数据
+   * @param {string} messageId - 消息ID
+   * @param {string} newChunk - 新的文本块
+   * @param {number} debounceMs - 防抖时间（毫秒）
+   */
+  const appendStreamingText = useCallback(
+    (messageId, newChunk, debounceMs = 100) => {
+      // 更新缓冲区
+      const currentBuffer = streamBufferRef.current.get(messageId) || '';
+      const updatedContent = currentBuffer + newChunk;
+      streamBufferRef.current.set(messageId, updatedContent);
+
+      // 清除之前的定时器
+      if (streamTimerRef.current.has(messageId)) {
+        clearTimeout(streamTimerRef.current.get(messageId));
+      }
+
+      // 设置新的防抖定时器
+      const timer = setTimeout(() => {
+        updateStreamingMessage(messageId, updatedContent, false);
+      }, debounceMs);
+
+      streamTimerRef.current.set(messageId, timer);
+    },
+    [updateStreamingMessage],
+  );
+
+  /**
+   * 完成流式消息
+   * @param {string} messageId - 消息ID
+   * @param {string} finalContent - 最终内容（可选，如果不提供则使用缓冲区内容）
+   */
+  const completeStreamingMessage = useCallback(
+    (messageId, finalContent = null) => {
+      const content =
+        finalContent || streamBufferRef.current.get(messageId) || '';
+      updateStreamingMessage(messageId, content, true);
+    },
+    [updateStreamingMessage],
+  );
+
+  /**
+   * 获取流式消息状态
+   * @param {string} messageId - 消息ID
+   * @returns {Object|null} 消息状态对象
+   */
+  const getStreamingMessage = useCallback(
+    messageId => {
+      return streamingMessages.get(messageId) || null;
+    },
+    [streamingMessages],
+  );
+
+  /**
+   * 清除特定的流式消息
+   * @param {string} messageId - 消息ID
+   */
+  const clearStreamingMessage = useCallback(messageId => {
+    setStreamingMessages(prev => {
+      const newMap = new Map(prev);
+      newMap.delete(messageId);
+      return newMap;
+    });
+
+    streamBufferRef.current.delete(messageId);
+    if (streamTimerRef.current.has(messageId)) {
+      clearTimeout(streamTimerRef.current.get(messageId));
+      streamTimerRef.current.delete(messageId);
+    }
+  }, []);
+
+  /**
+   * 清除所有流式消息
+   */
+  const clearAllStreamingMessages = useCallback(() => {
+    setStreamingMessages(new Map());
+    streamBufferRef.current.clear();
+
+    // 清理所有定时器
+    streamTimerRef.current.forEach(timer => clearTimeout(timer));
+    streamTimerRef.current.clear();
+  }, []);
+
+  /**
+   * 处理chat类型消息的流式更新
+   * @param {Object} chatMessage - chat类型的消息对象
+   */
+  const handleChatMessage = useCallback(
+    chatMessage => {
+      const messageId = chatMessage.MsgId;
+
+      switch (chatMessage.Chat.type) {
+        case 'data':
+          // 累积式流数据
+          const totalData = chatMessage.Chat.payload.total_data || '';
+          updateStreamingMessage(messageId, totalData, false);
+          break;
+
+        case 'end':
+          // 流结束
+          let finalContent = '';
+          if (chatMessage.Chat.payload.message.tool_calls) {
+            finalContent = `${
+              chatMessage.Chat.payload.message.content || ''
+            }<正在调用 ${
+              chatMessage.Chat.payload.message.tool_calls[0].function.name
+            } 工具>`;
+          } else {
+            finalContent = chatMessage.Chat.payload.message.content || '';
+          }
+          completeStreamingMessage(messageId, finalContent);
+          break;
+
+        case 'tool_call_begin':
+          completeStreamingMessage(
+            messageId,
+            `<正在调用 ${chatMessage.Chat.payload.tool_calls[0].function.name} 工具>`,
+          );
+          break;
+
+        case 'tool_call_end':
+          completeStreamingMessage(messageId, '<工具调用结束>');
+          break;
+
+        case 'info':
+          let infoContent = '';
+          switch (chatMessage.Chat.payload.message) {
+            case 'processing':
+              infoContent = 'AI正在思考...';
+              break;
+            case 'stoped':
+              infoContent = '<用户主动停止>';
+              break;
+            default:
+              infoContent = chatMessage.Chat.payload.message;
+          }
+          completeStreamingMessage(messageId, infoContent);
+          break;
+
+        case 'system_error':
+          completeStreamingMessage(
+            messageId,
+            chatMessage.Chat.payload.message.content,
+          );
+          break;
+
+        case 'error':
+          completeStreamingMessage(
+            messageId,
+            chatMessage.Chat.payload.message.error,
+          );
+          break;
+
+        default:
+          completeStreamingMessage(messageId, JSON.stringify(chatMessage.Chat));
+      }
+    },
+    [updateStreamingMessage, completeStreamingMessage],
+  );
+
+  // 清理效果
+  useEffect(() => {
+    const currentTimers = streamTimerRef.current;
+    return () => {
+      // 组件卸载时清理所有定时器
+      currentTimers.forEach(timer => clearTimeout(timer));
+    };
+  }, []);
+
+  return {
+    streamingMessages,
+    updateStreamingMessage,
+    appendStreamingText,
+    completeStreamingMessage,
+    getStreamingMessage,
+    clearStreamingMessage,
+    clearAllStreamingMessages,
+    handleChatMessage,
+  };
+}