#ifdef SUPPORT_AT_LEINIAO_API\r
#include "leiniao_api_at.h"\r
#endif\r
+#ifdef SUPPORT_ZHIHUI_AI_SERVICE\r
+#include "ai_at_cmd.h"\r
+#endif\r
+\r
static void register_at_service(void)\r
{\r
#ifdef SUPPORT_AT_GRAPHIC\r
at_cmd_table_t *leiniao_api_table = get_leiniao_api_cmd_table(&leiniao_api_cmd_count);\r
at_cmd_add_moudle(leiniao_api_table, leiniao_api_cmd_count);\r
#endif\r
+\r
+#ifdef SUPPORT_ZHIHUI_AI_SERVICE\r
+ uint32_t ai_cmd_count;\r
+ at_cmd_table_t *ai_table = get_ai_cmd_table(&ai_cmd_count);\r
+ at_cmd_add_moudle(ai_table, ai_cmd_count);\r
+#endif\r
+\r
}\r
\r
#ifdef CONFIG_OTA_UPDATE_SUPPORT\r
${ROOT_DIR}/open_source/openharmony/foundation/ace/ace_engine_lite/modules/netstack/websocket/include
)
+# 新的AI服务架构源文件 (LiteOS-M优化版v2)
set(AI_SOURCES
-${CMAKE_CURRENT_SOURCE_DIR}/src/ai_service_common.c
-${CMAKE_CURRENT_SOURCE_DIR}/src/asr_server_enhanced.c
-${CMAKE_CURRENT_SOURCE_DIR}/src/chat_server_enhanced.c
-${CMAKE_CURRENT_SOURCE_DIR}/src/tts_server_enhanced.c
-${CMAKE_CURRENT_SOURCE_DIR}/src/ai_service_manager.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/ai_connection_manager.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/ai_memory_pool.c
+${CMAKE_CURRENT_SOURCE_DIR}/src/ai_services.c
+${CMAKE_CURRENT_SOURCE_DIR}/example/ai_at_cmd.c
+${CMAKE_CURRENT_SOURCE_DIR}/example/ai_demo.c
)
set(SOURCES
set(COMPONENT_PUBLIC_CCFLAGS
)
+# LiteOS-M优化的编译选项
set(COMPONENT_CCFLAGS
-std=c99
-Wall
-ffunction-sections
-fdata-sections
-Wno-unused-parameter
+ -Wno-unused-function
-fno-exceptions
-fno-unwind-tables
-fno-asynchronous-unwind-tables
+ -Os # 优化代码大小，适合嵌入式系统
+ -fshort-enums # 使用最小的枚举类型
+ # -fstack-usage # 生成栈使用信息
+ # -Wstack-usage=2048 # 警告栈使用超过2KB
+ -fno-strict-aliasing # 避免严格别名优化问题
+ -fno-common # 避免公共符号
)
set(WHOLE_LINK
false
)
+# AI服务版本和功能定义
set(PUBLIC_DEFINES
-AI_SERVICE_VERSION_MAJOR=1
+AI_SERVICE_VERSION_MAJOR=2
AI_SERVICE_VERSION_MINOR=0
-AI_SERVICE_VERSION_PATCH=0
-SUPPORT_ZHIHUI_WEBSOCKET
+SUPPORT_ZHIHUI_AI_SERVICE
+
)
set(PRIVATE_DEFINES
--- /dev/null
+# AI Service Makefile - LiteOS-M优化版v2
+# 用于测试编译AI服务相关代码
+
+# 编译器设置
+CC = gcc
+CFLAGS = -Wall -Wextra -std=c99 -D__TEST_MODE__ -Wno-unused-function -Wno-unused-parameter
+INCLUDES = -Iinclude -I../../../include -I../../../middleware/utils/at/wstp_at/inc -I../../4gTest
+LDFLAGS = -lm
+
+# 目录设置
+SRC_DIR = src
+INC_DIR = include
+EXAMPLE_DIR = example
+BUILD_DIR = build
+
+# 源文件
+SOURCES = $(SRC_DIR)/ai_connection_manager.c \
+ $(SRC_DIR)/ai_memory_pool.c \
+ $(SRC_DIR)/ai_services.c
+
+# 示例文件
+EXAMPLE_SOURCES = $(EXAMPLE_DIR)/ai_demo.c \
+ $(EXAMPLE_DIR)/ai_at_cmd.c
+
+# 目标文件
+OBJECTS = $(SOURCES:$(SRC_DIR)/%.c=$(BUILD_DIR)/%.o)
+EXAMPLE_OBJECTS = $(EXAMPLE_SOURCES:$(EXAMPLE_DIR)/%.c=$(BUILD_DIR)/%.o)
+
+# 目标程序
+TARGET = $(BUILD_DIR)/ai_demo
+AT_TEST_TARGET = $(BUILD_DIR)/ai_at_test
+LIBRARY = $(BUILD_DIR)/libai_service.a
+
+# 默认目标
+all: $(TARGET) $(AT_TEST_TARGET)
+
+# 创建构建目录
+$(BUILD_DIR):
+ mkdir -p $(BUILD_DIR)
+
+# 编译源文件
+$(BUILD_DIR)/%.o: $(SRC_DIR)/%.c | $(BUILD_DIR)
+ $(CC) $(CFLAGS) $(INCLUDES) -c $< -o $@
+
+# 编译示例文件
+$(BUILD_DIR)/%.o: $(EXAMPLE_DIR)/%.c | $(BUILD_DIR)
+ $(CC) $(CFLAGS) $(INCLUDES) -c $< -o $@
+
+# 创建静态库
+$(LIBRARY): $(OBJECTS)
+ ar rcs $@ $^
+
+# 创建演示程序
+$(TARGET): $(LIBRARY) $(BUILD_DIR)/ai_demo.o
+ $(CC) $(BUILD_DIR)/ai_demo.o -L$(BUILD_DIR) -lai_service $(LDFLAGS) -o $@
+
+# 创建AT命令测试程序
+$(AT_TEST_TARGET): $(LIBRARY) $(BUILD_DIR)/ai_at_cmd.o
+ $(CC) $(BUILD_DIR)/ai_at_cmd.o -L$(BUILD_DIR) -lai_service $(LDFLAGS) -o $@
+
+# 运行演示程序
+run: $(TARGET)
+ ./$(TARGET)
+
+# 编译测试
+test: $(TARGET)
+ @echo "=== AI Service Compilation Test ==="
+ @echo "✓ All source files compiled successfully"
+ @echo "✓ Library created: $(LIBRARY)"
+ @echo "✓ Demo program created: $(TARGET)"
+ @echo "=== Running Demo Program ==="
+ ./$(TARGET)
+
+# AT命令测试
+test-at: $(AT_TEST_TARGET)
+ @echo "=== AI AT Command Test ==="
+ @echo "✓ AT command test program created: $(AT_TEST_TARGET)"
+ @echo "=== Running AT Command Tests ==="
+ ./$(AT_TEST_TARGET)
+
+# 运行AT测试程序
+run-at: $(AT_TEST_TARGET)
+ ./$(AT_TEST_TARGET)
+
+# 检查头文件
+check-headers:
+ @echo "=== Checking Header Files ==="
+ @for header in $(INC_DIR)/*.h; do \
+ echo "Checking $$header..."; \
+ $(CC) $(CFLAGS) $(INCLUDES) -fsyntax-only -c $$header -o /dev/null 2>/dev/null && \
+ echo "✓ $$header: OK" || echo "✗ $$header: ERROR"; \
+ done
+
+# 代码统计
+stats:
+ @echo "=== Code Statistics ==="
+ @echo "Header files:"
+ @find $(INC_DIR) -name "*.h" | wc -l
+ @echo "Source files:"
+ @find $(SRC_DIR) -name "*.c" | wc -l
+ @echo "Example files:"
+ @find $(EXAMPLE_DIR) -name "*.c" | wc -l
+ @echo "Total lines of code:"
+ @find $(INC_DIR) $(SRC_DIR) $(EXAMPLE_DIR) -name "*.c" -o -name "*.h" | xargs wc -l | tail -1
+
+# 清理
+clean:
+ rm -rf $(BUILD_DIR)
+
+# 重新构建
+rebuild: clean all
+
+# 安装头文件（用于系统集成）
+install-headers:
+ @echo "=== Installing Headers ==="
+ mkdir -p /usr/local/include/ai_service
+ cp $(INC_DIR)/*.h /usr/local/include/ai_service/
+ @echo "Headers installed to /usr/local/include/ai_service/"
+
+# 帮助信息
+help:
+ @echo "AI Service Makefile - Available targets:"
+ @echo " all - Build library, demo and AT test programs"
+ @echo " $(LIBRARY) - Build static library only"
+ @echo " $(TARGET) - Build demo program"
+ @echo " $(AT_TEST_TARGET) - Build AT command test program"
+ @echo " run - Build and run demo program"
+ @echo " run-at - Build and run AT test program"
+ @echo " test - Compile test and run demo"
+ @echo " test-at - Compile and run AT command tests"
+ @echo " check-headers - Check header file syntax"
+ @echo " stats - Show code statistics"
+ @echo " clean - Remove build files"
+ @echo " rebuild - Clean and rebuild"
+ @echo " install-headers- Install headers to system"
+ @echo " help - Show this help message"
+
+# 声明伪目标
+.PHONY: all run test check-headers stats clean rebuild install-headers help
\ No newline at end of file
--- /dev/null
+# 鸿蒙AI服务-架构设计图（LiteOS-M优化版v2）
+
+## 🎯 优化目标（修正版）
+针对LiteOS-M系统的资源限制，在**保持多WebSocket连接快速响应**的前提下优化：
+- **内存占用优化**：总内存占用 < 80KB（保留连接优势）
+- **线程优化**：保持响应性能，优化线程资源使用
+- **缓冲区共享**：最大化缓冲区复用效率
+- **状态管理统一**：简化跨服务状态协调
+- **功能模块化**：支持按需启用/禁用
+
+## 📊 设计理念修正
+
+### ✅ **保持多连接优势**：
+1. **并发连接**：ASR/Chat/TTS独立WebSocket连接，避免握手等待
+2. **快速响应**：每个服务独立建连，互不影响响应时间
+3. **服务隔离**：单个连接异常不影响其他服务
+4. **负载分散**：避免单连接成为性能瓶颈
+
+### 🔧 **其他资源优化**：
+- 缓冲区管理优化
+- 内存池复用
+- 线程栈大小优化
+- JSON解析轻量化
+
+## 🔧 优化后的架构设计
+
+### 1. 多连接管理器（Multi-Connection Manager）
+
+```
+┌─────────────────────────────────────────────────────────┐
+│ AI Service Manager │
+│ ┌─────────────────┬─────────────────┬─────────────────┐│
+│ │ ASR Connection │ Chat Connection │ TTS Connection ││
+│ │ ┌───────────┐ │ ┌───────────┐ │ ┌───────────┐ ││
+│ │ │WebSocket-1│ │ │WebSocket-2│ │ │WebSocket-3│ ││
+│ │ │(快速握手) │ │ │(快速握手) │ │ │(快速握手) │ ││
+│ │ └───────────┘ │ └───────────┘ │ └───────────┘ ││
+│ └─────────────────┴─────────────────┴─────────────────┘│
+│ ┌─────────────────────────────────────────────────────┐│
+│ │ Connection Pool Manager ││
+│ │ • 并发建连策略 ││
+│ │ • 连接健康检测 ││
+│ │ • 智能重连管理 ││
+│ └─────────────────────────────────────────────────────┘│
+└─────────────────────────────────────────────────────────┘
+```
+
+#### 🎯 优化要点：
+- **并发建连**：3个WebSocket同时建立连接，减少总等待时间
+- **连接池复用**：预建立备用连接，故障时快速切换
+- **智能重连**：根据服务类型采用不同重连策略
+- **连接优先级**：ASR > TTS > Chat（按响应时间要求排序）
+
+#### 💻 接口优化：
+```c
+// 多连接配置
+typedef struct {
+ char asr_url[128];
+ char chat_url[128];
+ char tts_url[128];
+ uint16_t connect_timeout_ms; // 连接超时：3秒
+ uint8_t concurrent_connect; // 并发建连开关
+ uint8_t backup_connections; // 备用连接数：1个
+} ai_multi_connection_config_t;
+
+// 并发连接管理
+ai_error_t ai_connections_init_concurrent(ai_multi_connection_config_t *config);
+ai_error_t ai_connection_send(uint8_t service_type, const char *data, uint16_t len);
+uint8_t ai_connection_get_status(uint8_t service_type); // 0=断开, 1=连接中, 2=已连接
+```
+
+### 2. 优化的线程管理
+
+```
+┌─────────────────────────────────────────────────────────┐
+│ Thread Pool (优化版) │
+│ ┌─────────────────────────────────────────────────────┐│
+│ │ Connection Thread Pool (3个) ││
+│ │ ┌─────────────┬─────────────┬─────────────────────┐││
+│ │ │ASR Connect │Chat Connect │TTS Connect │││
+│ │ │Thread │Thread │Thread │││
+│ │ │(4KB Stack) │(4KB Stack) │(4KB Stack) │││
+│ │ └─────────────┴─────────────┴─────────────────────┘││
+│ └─────────────────────────────────────────────────────┘│
+│ ┌─────────────────────────────────────────────────────┐│
+│ │ Shared Worker Thread (1个) ││
+│ │ • 音频处理 (录音+播放) ││
+│ │ • JSON解析 ││
+│ │ • 状态管理 ││
+│ │ (6KB Stack) ││
+│ └─────────────────────────────────────────────────────┘│
+└─────────────────────────────────────────────────────────┘
+```
+
+#### 🎯 优化要点：
+- **连接线程精简**：每个连接线程仅负责WebSocket通信
+- **工作线程共享**：音频处理、JSON解析等共享一个工作线程
+- **栈大小优化**：连接线程4KB栈，工作线程6KB栈
+- **线程复用**：连接建立后，连接线程可复用为消息处理线程
+
+#### 💻 线程配置：
+```c
+// 线程配置优化
+typedef struct {
+ uint16_t connection_stack_size; // 4KB
+ uint16_t worker_stack_size; // 6KB
+ uint8_t connection_priority; // 高优先级
+ uint8_t worker_priority; // 中优先级
+} ai_thread_config_t;
+
+// 线程池管理
+ai_error_t ai_thread_pool_init(ai_thread_config_t *config);
+ai_error_t ai_thread_pool_assign_task(uint8_t thread_type, void *task);
+```
+
+### 3. 智能缓冲区管理
+
+```
+┌─────────────────────────────────────────────────────────┐
+│ Memory Pool Manager │
+│ ┌─────────────────────────────────────────────────────┐│
+│ │ Shared Buffer Pool (6KB) ││
+│ │ ┌─────────────┬─────────────┬─────────────────────┐││
+│ │ │Audio In │Audio Out │Network Buffers │││
+│ │ │Buffer │Buffer │(ASR/Chat/TTS) │││
+│ │ │(2KB) │(1KB) │(3KB 动态分配) │││
+│ │ └─────────────┴─────────────┴─────────────────────┘││
+│ └─────────────────────────────────────────────────────┘│
+│ ┌─────────────────────────────────────────────────────┐│
+│ │ Connection Buffers (3KB) ││
+│ │ • ASR发送缓冲区: 1KB ││
+│ │ • Chat发送缓冲区: 1KB ││
+│ │ • TTS发送缓冲区: 1KB ││
+│ └─────────────────────────────────────────────────────┘│
+└─────────────────────────────────────────────────────────┘
+```
+
+#### 🎯 优化要点：
+- **分层缓冲区**：音频缓冲区固定，网络缓冲区动态分配
+- **智能复用**：网络缓冲区在服务间动态分配
+- **内存池**：预分配内存池，避免碎片化
+- **溢出保护**：缓冲区边界检查和自动扩展
+
+#### 💻 缓冲区管理：
+```c
+// 缓冲区配置
+#define AI_AUDIO_IN_BUFFER_SIZE 2048 // 录音缓冲区
+#define AI_AUDIO_OUT_BUFFER_SIZE 1024 // 播放缓冲区
+#define AI_NETWORK_POOL_SIZE 3072 // 网络缓冲池
+#define AI_CONNECTION_BUFFER_SIZE 1024 // 每连接缓冲区
+
+// 动态缓冲区分配
+typedef struct {
+ uint8_t *buffer;
+ uint16_t size;
+ uint16_t used;
+ uint8_t service_id;
+} ai_buffer_t;
+
+ai_buffer_t* ai_buffer_alloc(uint8_t service_id, uint16_t size);
+void ai_buffer_free(ai_buffer_t *buffer);
+ai_error_t ai_buffer_resize(ai_buffer_t *buffer, uint16_t new_size);
+```
+
+### 4. 连接建立优化策略
+
+#### 并发连接时序：
+```
+时间轴: 0ms 500ms 1000ms 1500ms 2000ms
+ASR: [建连开始]----[连接成功]
+Chat: [建连开始]--------[连接成功]
+TTS: [建连开始]----------[连接成功]
+总计: [开始]----------------[全部完成] ≈ 1.5s
+
+vs 串行连接:
+ASR: [建连]----[成功]
+Chat: [建连]----[成功]
+TTS: [建连]----[成功]
+总计: [开始]------------------------[完成] ≈ 3s
+```
+
+#### 🎯 连接策略：
+```c
+// 并发连接策略
+typedef enum {
+ CONNECT_STRATEGY_CONCURRENT = 0, // 并发连接（默认）
+ CONNECT_STRATEGY_PRIORITY, // 按优先级顺序连接
+ CONNECT_STRATEGY_ON_DEMAND // 按需连接
+} ai_connect_strategy_t;
+
+// 连接管理
+typedef struct {
+ ai_connect_strategy_t strategy;
+ uint16_t connect_timeout_ms; // 单个连接超时
+ uint16_t total_timeout_ms; // 总连接超时
+ uint8_t retry_count; // 重试次数
+ uint16_t retry_interval_ms; // 重试间隔
+} ai_connect_config_t;
+
+ai_error_t ai_connect_all_services(ai_connect_config_t *config);
+```
+
+### 5. 状态机优化（保持多连接）
+
+```
+┌─────────────────────────────────────────────────────────┐
+│ Global State Machine │
+│ │
+│ INITIALIZING → CONNECTING → READY → ACTIVE → IDLE │
+│ ↑ ↓ │
+│ └──── ERROR ←──┘ │
+│ │
+│ 连接状态矩阵: │
+│ ┌─────────┬─────────┬─────────┬─────────────────────┐ │
+│ │ 全局状态 │ ASR │ Chat │ TTS │ │
+│ ├─────────┼─────────┼─────────┼─────────────────────┤ │
+│ │ READY │ 已连接 │ 已连接 │ 已连接 │ │
+│ │ PARTIAL │ 已连接 │ 连接中 │ 已连接 │ │
+│ │ DEGRADED│ 已连接 │ 断开 │ 已连接 │ │
+│ └─────────┴─────────┴─────────┴─────────────────────┘ │
+└─────────────────────────────────────────────────────────┘
+```
+
+#### 🎯 状态管理优化：
+```c
+// 全局状态
+typedef enum {
+ AI_STATE_INITIALIZING = 0,
+ AI_STATE_CONNECTING, // 正在建立连接
+ AI_STATE_READY, // 所有服务就绪
+ AI_STATE_PARTIAL, // 部分服务可用
+ AI_STATE_DEGRADED, // 降级模式
+ AI_STATE_ERROR // 错误状态
+} ai_global_state_t;
+
+// 连接状态矩阵
+typedef struct {
+ uint8_t asr_connected : 1;
+ uint8_t chat_connected : 1;
+ uint8_t tts_connected : 1;
+ uint8_t reserved : 5;
+} ai_connection_matrix_t;
+
+ai_global_state_t ai_get_global_state(void);
+ai_connection_matrix_t ai_get_connection_matrix(void);
+```
+
+### 6. 性能监控和优化
+
+#### 连接性能监控：
+```c
+// 连接性能指标
+typedef struct {
+ uint32_t connect_time_ms[3]; // 各服务连接时间
+ uint32_t total_connect_time_ms; // 总连接时间
+ uint16_t retry_count[3]; // 重试次数
+ uint8_t success_rate; // 连接成功率
+ uint32_t last_connect_timestamp; // 最后连接时间
+} ai_connect_metrics_t;
+
+// 性能优化建议
+typedef struct {
+ bool enable_connection_cache; // 启用连接缓存
+ bool enable_dns_cache; // 启用DNS缓存
+ uint16_t keepalive_interval_ms; // 心跳间隔
+ uint8_t concurrent_limit; // 并发连接限制
+} ai_performance_config_t;
+```
+
+## 📈 优化后性能对比
+
+| 指标 | 原设计 | 单连接方案 | **多连接优化方案** | 改善 |
+|------|--------|------------|-------------------|------|
+| 连接建立时间 | ~3s(串行) | ~1s | **~1.5s(并发)** | ↓50% |
+| 内存占用 | ~200KB | ~48KB | **~75KB** | ↓62% |
+| 线程数量 | 8个 | 3个 | **4个** | ↓50% |
+| 响应延迟 | 基准 | +握手延迟 | **无额外延迟** | 最优 |
+| 服务可用性 | 基准 | 单点故障 | **服务隔离** | 最优 |
+| 并发处理能力 | 基准 | 受限 | **完全并发** | 最优 |
+
+## 🔄 连接建立流程优化
+
+### 智能连接策略：
+```c
+// 连接建立流程
+ai_error_t ai_smart_connect_all(void) {
+ // 1. 并发启动所有连接
+ ai_start_concurrent_connections();
+
+ // 2. 等待关键服务（ASR优先）
+ if (ai_wait_service_ready(AI_SERVICE_ASR, 1000) == AI_OK) {
+ // ASR就绪，可以开始语音交互
+ ai_set_state(AI_STATE_PARTIAL);
+ }
+
+ // 3. 等待其他服务
+ ai_wait_all_services_ready(2000); // 最多等待2秒
+
+ // 4. 根据连接情况设置状态
+ ai_connection_matrix_t matrix = ai_get_connection_matrix();
+ if (matrix.asr_connected && matrix.chat_connected && matrix.tts_connected) {
+ ai_set_state(AI_STATE_READY);
+ } else if (matrix.asr_connected) {
+ ai_set_state(AI_STATE_DEGRADED); // 至少ASR可用
+ }
+
+ return AI_OK;
+}
+```
+
+## 🛡️ 可靠性保障（多连接版）
+
+### 1. 连接健康管理：
+- **独立心跳**：每个连接独立心跳检测
+- **故障隔离**：单个连接故障不影响其他服务
+- **智能重连**：根据服务重要性采用不同重连策略
+- **降级策略**：部分服务不可用时的功能降级
+
+### 2. 资源保护：
+- **连接数限制**：最多3+1个连接（3个主连接+1个备用）
+- **内存保护**：连接缓冲区独立管理，防止相互影响
+- **超时控制**：连接建立和数据传输超时保护
+
+## 🎯 总结
+
+### ✅ **多连接方案优势**：
+1. **快速响应**：并发建连，减少50%连接等待时间
+2. **服务隔离**：单个服务故障不影响其他服务
+3. **并发处理**：真正的并发AI服务处理能力
+4. **用户体验**：无握手等待，即时响应
+
+### ✅ **资源优化效果**：
+1. **内存优化**：通过缓冲区共享和智能分配，减少62%内存使用
+2. **线程优化**：精简线程设计，减少50%线程数量
+3. **性能监控**：实时连接性能监控和优化建议
+
+### 🚀 **最佳实践**：
+- 保持多WebSocket连接的响应优势
+- 通过其他维度优化资源使用
+- 智能连接管理和故障恢复
+- 适合LiteOS-M的轻量级实现
+
+这个方案在保持快速响应的同时，通过缓冲区共享、线程优化、内存池等技术大幅降低了资源占用，是针对LiteOS-M系统的最佳平衡方案。
\ No newline at end of file
+++ /dev/null
-# AI AT Test Module - AI测试AT命令模块
-
-## 概述
-
-本模块从 `cat1_at_cmd.c` 中拆分出AI相关的测试功能，提供了一套完整的AT命令来测试ASR（语音识别）、TTS（文本转语音）、Chat（对话）和AI Media（AI媒体）服务。
-
-## 文件结构
-
-```
-ai/example/
-├── ai_at_test.h # AI AT测试模块头文件
-├── ai_at_test.c # AI AT测试模块实现
-├── ai_at_test_example.c # 使用示例
-└── AI_AT_TEST_README.md # 本说明文档
-```
-
-## 功能特性
-
-### 1. ASR (语音识别) 测试命令
-
-| 命令 | 功能 | 参数 |
-|------|------|------|
-| `AT^ASRSTART` | 启动ASR服务 | 无 |
-| `AT^ASRSTOP` | 停止ASR服务 | 无 |
-| `AT^ASRRECORDTEST` | ASR录音测试 | 无 |
-| `AT^ASRTASKSTART` | 启动ASR任务 | 无 |
-
-### 2. TTS (文本转语音) 测试命令
-
-| 命令 | 功能 | 参数 |
-|------|------|------|
-| `AT^TTSSTART` | 启动TTS服务 | 无 |
-| `AT^TTSSTOP` | 停止TTS服务 | 无 |
-| `AT^TTSSAY=text` | 文本转语音 | text: 要转换的文本 |
-
-### 3. Chat (对话) 测试命令
-
-| 命令 | 功能 | 参数 |
-|------|------|------|
-| `AT^CHATSEND=type,message` | 发送Chat消息 | type: 消息类型(0-文本)<br>message: 消息内容 |
-
-### 4. AI Media (AI媒体) 测试命令
-
-| 命令 | 功能 | 参数 |
-|------|------|------|
-| `AT^AIRECORDSTART=format` | 启动AI录音 | format: 音频格式(pcm/mp3/opus) |
-| `AT^AIRECORDSTOP` | 停止AI录音 | 无 |
-| `AT^AIPLAYSTART=format` | 启动AI播放 | format: 音频格式(pcm/mp3/opus) |
-| `AT^AIPLAYSTOP` | 停止AI播放 | 无 |
-| `AT^AIMEDIASTATUS` | 查询AI媒体状态 | 无 |
-
-### 5. 综合测试命令
-
-| 命令 | 功能 | 参数 |
-|------|------|------|
-| `AT^AISTATUS` | 查询AI服务状态 | 无 |
-| `AT^AITEST=duration` | 完整AI测试 | duration: 测试时长(秒) |
-
-## 使用方法
-
-### 1. 基本集成
-
-```c
-#include "ai_at_test.h"
-
-// 初始化AI AT测试模块
-int ret = ai_at_test_init();
-if (ret != 0) {
- printf("Failed to initialize AI AT test module\n");
- return -1;
-}
-
-// 获取AT命令表
-uint32_t cmd_count;
-at_cmd_table_t *cmd_table = get_ai_at_cmd_table(&cmd_count);
-
-// 注册AT命令到系统AT命令处理器
-// (具体注册方法取决于系统的AT命令框架)
-
-// 反初始化
-ai_at_test_deinit();
-```
-
-### 2. 与原有AT命令系统集成
-
-在原有的 `cat1_at_cmd.c` 中添加AI命令：
-
-```c
-#include "ai_at_test.h"
-
-// 在 get_cat1_cmd_table 函数中添加AI命令
-at_cmd_table_t *get_cat1_cmd_table(uint32_t *cmd_count)
-{
- // 获取原有命令数量
- uint32_t cat1_cmd_count = ARRAY_COUNT(g_cat1_cmd);
-
- // 获取AI命令
- uint32_t ai_cmd_count;
- at_cmd_table_t *ai_cmd_table = get_ai_at_cmd_table(&ai_cmd_count);
-
- // 合并命令表（需要动态分配内存）
- // ...
-
- *cmd_count = cat1_cmd_count + ai_cmd_count;
- return merged_table;
-}
-```
-
-## 测试示例
-
-### 1. ASR测试流程
-
-```bash
-# 1. 启动ASR服务
-AT^ASRSTART
-
-# 2. 启动ASR任务
-AT^ASRTASKSTART
-
-# 3. 进行录音测试
-AT^ASRRECORDTEST
-
-# 4. 停止ASR服务
-AT^ASRSTOP
-```
-
-### 2. TTS测试流程
-
-```bash
-# 1. 启动TTS服务
-AT^TTSSTART
-
-# 2. 文本转语音
-AT^TTSSAY=Hello, this is a TTS test
-
-# 3. 停止TTS服务
-AT^TTSSTOP
-```
-
-### 3. AI媒体测试流程
-
-```bash
-# 1. 启动录音
-AT^AIRECORDSTART=pcm
-
-# 2. 查询状态
-AT^AIMEDIASTATUS
-
-# 3. 停止录音
-AT^AIRECORDSTOP
-
-# 4. 启动播放
-AT^AIPLAYSTART=pcm
-
-# 5. 停止播放
-AT^AIPLAYSTOP
-```
-
-### 4. 完整语音对话测试
-
-```bash
-# 1. 查询AI服务状态
-AT^AISTATUS
-
-# 2. 启动ASR和录音
-AT^ASRSTART
-AT^AIRECORDSTART=pcm
-
-# 3. (等待录音完成后) 停止录音
-AT^AIRECORDSTOP
-
-# 4. 发送识别结果到Chat
-AT^CHATSEND=0,User said something
-
-# 5. 启动TTS播放回复
-AT^TTSSTART
-AT^TTSSAY=AI response to user
-
-# 6. 清理服务
-AT^ASRSTOP
-AT^TTSSTOP
-```
-
-### 5. 快速完整测试
-
-```bash
-# 运行10秒完整AI测试
-AT^AITEST=10
-```
-
-## 配置选项
-
-### 音频格式支持
-
-- **PCM**: 未压缩的脉冲编码调制格式
-- **MP3**: MPEG Audio Layer III 压缩格式
-- **OPUS**: 开源的音频编解码器
-
-### 消息类型
-
-- **0**: 文本消息（用于Chat服务）
-
-## 错误处理
-
-所有AT命令都会返回标准的错误码：
-
-- `ERRCODE_SUCC (0)`: 命令执行成功
-- `ERRCODE_FAIL (-1)`: 命令执行失败
-
-详细的错误信息会通过日志输出，格式为：`[AI_AT] 错误描述`
-
-## 依赖项
-
-### 必需的头文件
-
-```c
-#include "at_cmd_api.h" // AT命令API
-#include "cat1_ws.h" // CAT1 WebSocket接口
-#include "ai_media.h" // AI媒体接口
-```
-
-### 必需的函数
-
-模块依赖以下外部函数，需要在链接时提供：
-
-```c
-// ASR相关
-void uapi_start_asr(void);
-void uapi_stop_asr(void);
-void uapi_start_asr_task(void);
-void asr_record_test(void);
-
-// TTS相关
-void uapi_start_tts(void);
-void uapi_stop_tts(void);
-bool uapi_start_tts_single_txt(char *buf);
-
-// Chat相关
-bool send_ai_txt(uint8_t type, char *msg);
-
-// AI Media相关
-void ai_media_record_start(uint8_t* format);
-void ai_media_record_stop(void);
-uint8_t ai_media_get_record_status(void);
-void ai_media_play_start(uint8_t* format);
-void ai_media_play_stop(void);
-uint8_t ai_media_get_play_status(void);
-
-// 状态查询相关
-uint8_t get_ai_asr_service_init_flag(void);
-uint8_t get_ai_chat_service_init_flag(void);
-uint8_t get_ai_tts_server_init_flag(void);
-```
-
-## 编译配置
-
-### CMakeLists.txt 示例
-
-```cmake
-# 添加AI AT测试模块
-set(AI_AT_TEST_SOURCES
- ${CMAKE_CURRENT_SOURCE_DIR}/ai/example/ai_at_test.c
-)
-
-# 包含头文件路径
-include_directories(
- ${CMAKE_CURRENT_SOURCE_DIR}/ai/example
- ${CMAKE_CURRENT_SOURCE_DIR}/ai/include
-)
-
-# 添加到目标
-target_sources(your_target PRIVATE ${AI_AT_TEST_SOURCES})
-```
-
-## 调试信息
-
-### 日志级别
-
-所有日志都使用 `[AI_AT]` 前缀，便于过滤和调试：
-
-```
-[AI_AT] Starting ASR service...
-[AI_AT] ASR service start command sent
-[AI_AT] TTS converting text to speech: Hello World
-[AI_AT] AI media recording started successfully
-```
-
-### 调试技巧
-
-1. **启用详细日志**: 确保系统日志级别允许 `printf` 输出
-2. **状态查询**: 使用 `AT^AISTATUS` 和 `AT^AIMEDIASTATUS` 查询服务状态
-3. **分步测试**: 先测试单个服务，再测试组合功能
-4. **错误检查**: 注意命令返回值和日志中的错误信息
-
-## 扩展开发
-
-### 添加新的AT命令
-
-1. 在 `ai_at_test.c` 中添加命令处理函数：
-
-```c
-static uint32_t at_new_command(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
-{
- // 命令处理逻辑
- return ERRCODE_SUCC;
-}
-```
-
-2. 在 `g_ai_at_cmd_table` 中添加命令条目：
-
-```c
-{ (char *)"AT^NEWCMD", at_new_command, (char *)"parameter_description" },
-```
-
-### 自定义错误处理
-
-可以修改错误处理逻辑，添加更详细的错误码和描述：
-
-```c
-typedef enum {
- AI_AT_ERROR_NONE = 0,
- AI_AT_ERROR_PARAM_INVALID,
- AI_AT_ERROR_SERVICE_NOT_READY,
- AI_AT_ERROR_RESOURCE_BUSY,
- // ...
-} ai_at_error_t;
-```
-
-## 常见问题
-
-### Q1: AT命令执行失败怎么办？
-
-**A**: 检查以下几点：
-1. 确认相关AI服务已正确初始化
-2. 检查参数格式是否正确
-3. 查看系统日志中的详细错误信息
-4. 确认系统资源（内存、线程等）是否充足
-
-### Q2: 如何集成到现有的AT命令系统？
-
-**A**: 有两种方式：
-1. **静态集成**: 直接将AI命令添加到现有的命令表中
-2. **动态集成**: 运行时合并命令表，需要动态内存分配
-
-### Q3: 音频格式不支持怎么办？
-
-**A**:
-1. 检查底层AI媒体服务是否支持该格式
-2. 使用默认的PCM格式进行测试
-3. 根据需要扩展 `GetAudioFormatFromString` 函数
-
-### Q4: 如何添加新的AI服务测试？
-
-**A**:
-1. 在相应的AI服务模块中添加测试接口
-2. 在本模块中添加对应的AT命令处理函数
-3. 更新命令表和文档
-
-## 版本历史
-
-- **v1.0** (2024-12-28): 初始版本，从 `cat1_at_cmd.c` 拆分AI测试功能
- - 支持ASR、TTS、Chat、AI Media基本测试命令
- - 提供完整的使用示例和文档
- - 支持音频格式配置和状态查询
-
-## 贡献指南
-
-1. 遵循现有的代码风格和注释规范
-2. 添加新功能时同步更新文档
-3. 确保新增的AT命令有对应的测试示例
-4. 保持向后兼容性
-
-## 许可证
-
-Copyright (c) CompanyNameMagicTag. 2023-2023. All rights reserved.
\ No newline at end of file
+++ /dev/null
-#===============================================================================
-# @brief cmake file
-# Copyright (c) @CompanyNameMagicTag 2022-2022. All rights reserved.
-#===============================================================================
-
-set(COMPONENT_NAME "aiAtTest")
-
-set(PUBLIC_HEADER
-)
-
-set(PRIVATE_HEADER
-${ROOT_DIR}/zhihui/ai/include
-${ROOT_DIR}/zhihui/ai/media
-${ROOT_DIR}/zhihui/4gTest
-)
-
-set(AI_SOURCES
-${CMAKE_CURRENT_SOURCE_DIR}/ai_at_test.c
-${CMAKE_CURRENT_SOURCE_DIR}/ai_at_test_example.c
-)
-
-set(SOURCES
- ${AI_SOURCES}
-)
-
-set(COMPONENT_PUBLIC_CCFLAGS
-)
-
-set(COMPONENT_CCFLAGS
- -std=c99
- -Wall
- -Wextra
- -Werror
- -Wno-unused-parameter
- -fno-exceptions
- -fno-unwind-tables
- -fno-asynchronous-unwind-tables
-)
-
-set(WHOLE_LINK
- true
-)
-
-set(MAIN_COMPONENT
- false
-)
-
-set(PUBLIC_DEFINES
-AI_AT_TEST_VERSION_MAJOR=1
-AI_AT_TEST_VERSION_MINOR=0
-)
-
-set(PRIVATE_DEFINES
-)
-
-build_component()
\ No newline at end of file
--- /dev/null
+/**
+ * @file ai_at_cmd.c
+ * @brief AI服务AT命令实现 - LiteOS AT系统集成版
+ * @version 2.0.0
+ * @date 2024-09-02
+ *
+ * 本文件提供AI服务的AT命令功能，集成到LiteOS AT指令系统中
+ */
+
+#ifdef __TEST_MODE__
+/* 测试模式下的模拟定义 */
+#define UNUSED(x) ((void)(x))
+#define ERRCODE_SUCC 0
+#define ERRCODE_FAIL (-1)
+#else
+#include "at_cmd_api.h"
+#endif
+
+#include "ai_at_cmd.h"
+#include "ai_connection_manager.h"
+#include "ai_memory_pool.h"
+#include "ai_services.h"
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <time.h>
+#ifdef __TEST_MODE__
+#include <unistd.h>
+#endif
+
+#ifdef __cplusplus
+#if __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+#endif /* __cplusplus */
+
+/* ================================ 宏定义和常量 ================================ */
+#ifndef UNUSED
+#define UNUSED(var) do { (void)(var); } while (0)
+#endif
+
+#define ARRAY_COUNT(array) (sizeof(array) / sizeof(array[0]))
+#define AI_AT_MAX_ARGC 8
+#define AI_AT_MAX_ARGV_LEN 256
+#define AI_AT_SUCCESS 0
+#define AI_AT_FAILED (-1)
+
+/* 测试配置常量 */
+#define AI_AT_DEMO_ASR_URL "ws://amp.raisound.com/asr/ws"
+#define AI_AT_DEMO_CHAT_URL "ws://amp.raisound.com/chat/ws"
+#define AI_AT_DEMO_TTS_URL "ws://amp.raisound.com/tts/ws"
+#define AI_AT_DEMO_AUDIO_SIZE 1024
+#define AI_AT_DEMO_CHAT_MESSAGE "你好，我是AI助手AT命令测试程序"
+#define AI_AT_DEMO_TTS_TEXT "欢迎使用AI语音服务AT命令测试"
+
+/* ================================ 全局变量 ================================ */
+
+static ai_services_context_t g_ai_services_context = {0};
+static bool g_ai_at_initialized = false;
+static uint32_t g_ai_session_counter = 0;
+
+/* 测试统计信息 */
+typedef struct {
+ uint32_t test_start_time;
+ uint32_t asr_tests_run;
+ uint32_t chat_tests_run;
+ uint32_t tts_tests_run;
+ uint32_t total_tests_run;
+ uint32_t tests_passed;
+ uint32_t tests_failed;
+} ai_at_test_stats_t;
+
+static ai_at_test_stats_t g_test_stats = {0};
+
+/* ================================ 内部函数 ================================ */
+
+/**
+ * @brief 将AT命令参数转换为参数数组
+ */
+static int ConvertCmdToParam(uint8_t *para, uint32_t paraLen,
+ uint8_t argv[AI_AT_MAX_ARGC][AI_AT_MAX_ARGV_LEN], uint32_t* argc)
+{
+ uint32_t pos = 0;
+ *argc = 0;
+
+ for (uint32_t i = 0; i < paraLen; i++) {
+ if ((para[i] == ',' || para[i] == ' ' || para[i] == '\n') && pos != 0) {
+ argv[*argc][pos] = '\0';
+ *argc += 1;
+ pos = 0;
+ if (*argc >= AI_AT_MAX_ARGC) {
+ return AI_AT_FAILED;
+ }
+ } else if (para[i] != ',' && para[i] != ' ' && para[i] != '\n') {
+ argv[*argc][pos] = para[i];
+ pos++;
+ if (pos >= AI_AT_MAX_ARGV_LEN) {
+ return AI_AT_FAILED;
+ }
+ }
+ }
+ if (pos != 0) {
+ argv[*argc][pos] = '\0';
+ *argc += 1;
+ }
+
+ return AI_AT_SUCCESS;
+}
+
+/**
+ * @brief 生成会话ID
+ */
+static char* generate_session_id(void)
+{
+ static char session_id[32];
+ snprintf(session_id, sizeof(session_id), "ai_session_%u", ++g_ai_session_counter);
+ return session_id;
+}
+
+/**
+ * @brief 获取当前时间戳（毫秒）
+ */
+static uint32_t get_timestamp_ms(void)
+{
+#ifndef __TEST_MODE__
+ return (uint32_t)(osKernelGetTickCount() * 1000 / osKernelGetTickFreq());
+#else
+ return (uint32_t)(clock() / (CLOCKS_PER_SEC / 1000));
+#endif
+}
+
+/**
+ * @brief AI服务回调函数
+ */
+static void ai_asr_result_callback(const asr_result_t *result, void *user_data)
+{
+ (void)user_data;
+ if (result == NULL) return;
+
+ printf("[AI_AT] ASR结果 - 会话: %s, 文本: %s, 置信度: %.2f, 最终: %s\n",
+ result->session_id, result->text, result->confidence,
+ result->is_final ? "是" : "否");
+}
+
+static void ai_chat_response_callback(const chat_message_t *message, void *user_data)
+{
+ (void)user_data;
+ if (message == NULL) return;
+
+ printf("[AI_AT] Chat响应 - 会话: %s, 内容: %s, 最终: %s\n",
+ message->session_id, message->content,
+ message->is_final ? "是" : "否");
+}
+
+static void ai_tts_result_callback(const tts_result_t *result, void *user_data)
+{
+ (void)user_data;
+ if (result == NULL) return;
+
+ printf("[AI_AT] TTS合成 - 会话: %s, 音频大小: %u字节, 最终: %s\n",
+ result->session_id, result->audio_size,
+ result->is_final ? "是" : "否");
+}
+
+/* ================================ AT命令处理函数 ================================ */
+
+/**
+ * @brief AT^AIINIT - 初始化AI服务
+ * 格式: AT^AIINIT
+ */
+static uint32_t at_ai_init(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
+{
+ UNUSED(para);
+ UNUSED(paraLen);
+ UNUSED(strCommonCmd);
+
+ printf("[AI_AT] 执行 AT^AIINIT - 初始化AI服务\n");
+
+ if (g_ai_at_initialized) {
+ printf("[AI_AT] AI服务已经初始化\n");
+ return ERRCODE_SUCC;
+ }
+
+ // 1. 初始化内存池
+ ai_memory_pool_config_t mem_config;
+ ai_memory_pool_create_default_config(&mem_config);
+
+ ai_error_t ret = ai_memory_pool_init(&mem_config);
+ if (ret != AI_OK) {
+ printf("[AI_AT] 内存池初始化失败: %d\n", ret);
+ return ERRCODE_FAIL;
+ }
+
+ // 2. 初始化连接管理器
+ ai_connection_manager_config_t conn_config;
+ ai_connection_manager_create_default_config(&conn_config);
+
+ // 设置演示服务URL
+ strncpy(conn_config.connection_config.asr_url, AI_AT_DEMO_ASR_URL, AI_MAX_URL_LENGTH - 1);
+ strncpy(conn_config.connection_config.chat_url, AI_AT_DEMO_CHAT_URL, AI_MAX_URL_LENGTH - 1);
+ strncpy(conn_config.connection_config.tts_url, AI_AT_DEMO_TTS_URL, AI_MAX_URL_LENGTH - 1);
+
+ ret = ai_connection_manager_init(&conn_config);
+ if (ret != AI_OK) {
+ printf("[AI_AT] 连接管理器初始化失败: %d\n", ret);
+ ai_memory_pool_destroy();
+ return ERRCODE_FAIL;
+ }
+
+ // 3. 初始化AI服务
+ ret = ai_services_init(&g_ai_services_context);
+ if (ret != AI_OK) {
+ printf("[AI_AT] AI服务初始化失败: %d\n", ret);
+ ai_connection_manager_destroy();
+ ai_memory_pool_destroy();
+ return ERRCODE_FAIL;
+ }
+
+ // 4. 设置回调函数
+ g_ai_services_context.asr_result_cb = ai_asr_result_callback;
+ g_ai_services_context.chat_response_cb = ai_chat_response_callback;
+ g_ai_services_context.tts_result_cb = ai_tts_result_callback;
+
+ g_ai_at_initialized = true;
+ printf("[AI_AT] AI服务初始化成功\n");
+
+ return ERRCODE_SUCC;
+}
+
+/**
+ * @brief AT^AICONNECT - 连接AI服务
+ * 格式: AT^AICONNECT
+ */
+static uint32_t at_ai_connect(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
+{
+ UNUSED(para);
+ UNUSED(paraLen);
+ UNUSED(strCommonCmd);
+
+ printf("[AI_AT] 执行 AT^AICONNECT - 连接AI服务\n");
+
+ if (!g_ai_at_initialized) {
+ printf("[AI_AT] AI服务未初始化，请先执行 AT^AIINIT\n");
+ return ERRCODE_FAIL;
+ }
+
+ ai_error_t ret = ai_connection_manager_start_all();
+ if (ret == AI_OK) {
+ printf("[AI_AT] 所有AI服务连接启动成功\n");
+ return ERRCODE_SUCC;
+ } else {
+ printf("[AI_AT] AI服务连接启动失败: %d\n", ret);
+ return ERRCODE_FAIL;
+ }
+}
+
+/**
+ * @brief AT^AISTATUS - 查询AI服务状态
+ * 格式: AT^AISTATUS
+ */
+static uint32_t at_ai_status(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
+{
+ UNUSED(para);
+ UNUSED(paraLen);
+ UNUSED(strCommonCmd);
+
+ printf("[AI_AT] 执行 AT^AISTATUS - 查询AI服务状态\n");
+
+ if (!g_ai_at_initialized) {
+ printf("[AI_AT] 状态: 未初始化\n");
+ return ERRCODE_SUCC;
+ }
+
+ // 获取连接状态
+ ai_global_state_t global_state = ai_connection_manager_get_state();
+ const char* state_names[] = {
+ "未初始化", "初始化中", "连接中", "就绪",
+ "部分连接", "降级模式", "错误"
+ };
+
+ // 获取内存使用情况
+ const ai_memory_stats_t* mem_stats = ai_memory_pool_get_global_stats();
+
+ printf("[AI_AT] 全局状态: %s\n", state_names[global_state]);
+ printf("[AI_AT] 内存使用: %u/%u 字节 (%.1f%%)\n",
+ mem_stats->used_size, mem_stats->total_size,
+ (float)mem_stats->used_size * 100.0f / mem_stats->total_size);
+ printf("[AI_AT] 会话计数: %u\n", g_ai_session_counter);
+
+ return ERRCODE_SUCC;
+}
+
+/**
+ * @brief AT^AIASR - 测试ASR服务
+ * 格式: AT^AIASR=duration_ms
+ * 示例: AT^AIASR=5000
+ */
+static uint32_t at_ai_asr_test(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
+{
+ UNUSED(strCommonCmd);
+
+ printf("[AI_AT] 执行 AT^AIASR - 详细测试ASR服务\n");
+
+ if (!g_ai_at_initialized) {
+ printf("[AI_AT] AI服务未初始化\n");
+ g_test_stats.tests_failed++;
+ return ERRCODE_FAIL;
+ }
+
+ g_test_stats.total_tests_run++;
+ g_test_stats.asr_tests_run++;
+
+ uint32_t duration_ms = 5000; // 默认5秒
+
+ if (para != NULL && paraLen > 0) {
+ uint8_t argv[AI_AT_MAX_ARGC][AI_AT_MAX_ARGV_LEN] = { 0 };
+ uint32_t argc = 0;
+
+ int ret = ConvertCmdToParam(para, paraLen, argv, &argc);
+ if (ret == AI_AT_SUCCESS && argc > 0) {
+ duration_ms = (uint32_t)atoi((char*)argv[0]);
+ if (duration_ms == 0 || duration_ms > 30000) {
+ printf("[AI_AT] 无效的持续时间，范围: 1-30000 毫秒\n");
+ g_test_stats.tests_failed++;
+ return ERRCODE_FAIL;
+ }
+ }
+ }
+
+ // 检查ASR连接状态
+ ai_connection_state_t state = ai_connection_manager_get_connection_state(AI_SERVICE_ASR);
+ if (state != AI_CONN_STATE_CONNECTED) {
+ printf("[AI_AT] ASR服务未连接，状态: %d\n", state);
+ g_test_stats.tests_failed++;
+ return ERRCODE_FAIL;
+ }
+
+ char* session_id = generate_session_id();
+ uint32_t test_start = get_timestamp_ms();
+
+ printf("[AI_AT] 开始ASR测试 - 会话: %s, 持续时间: %u毫秒\n", session_id, duration_ms);
+
+ // 启动ASR识别
+ ai_error_t ret = ai_asr_start(&g_ai_services_context, session_id);
+ if (ret != AI_OK) {
+ printf("[AI_AT] ASR启动失败: %d\n", ret);
+ g_test_stats.tests_failed++;
+ return ERRCODE_FAIL;
+ }
+
+ // 生成并发送模拟音频数据
+ uint8_t *audio_data = malloc(AI_AT_DEMO_AUDIO_SIZE);
+ if (audio_data == NULL) {
+ printf("[AI_AT] 音频缓冲区分配失败\n");
+ ai_asr_stop(&g_ai_services_context);
+ g_test_stats.tests_failed++;
+ return ERRCODE_FAIL;
+ }
+
+ // 生成模拟音频数据（更真实的模式）
+ for (int i = 0; i < AI_AT_DEMO_AUDIO_SIZE; i++) {
+ audio_data[i] = (uint8_t)(i % 256);
+ }
+
+ printf("[AI_AT] 发送音频数据: %d 字节\n", AI_AT_DEMO_AUDIO_SIZE);
+ ret = ai_asr_send_audio(&g_ai_services_context, audio_data, AI_AT_DEMO_AUDIO_SIZE);
+ free(audio_data);
+
+ if (ret != AI_OK) {
+ printf("[AI_AT] 音频数据发送失败: %d\n", ret);
+ ai_asr_stop(&g_ai_services_context);
+ g_test_stats.tests_failed++;
+ return ERRCODE_FAIL;
+ }
+
+ // 等待指定时间
+ printf("[AI_AT] 等待ASR处理...\n");
+#ifndef __TEST_MODE__
+ osDelay(duration_ms > 2000 ? 2000 : duration_ms); // 最多等待2秒
+#else
+ usleep((duration_ms > 500000 ? 500000 : duration_ms * 1000)); // 测试模式最多等待500ms
+#endif
+
+ // 停止ASR
+ ai_asr_stop(&g_ai_services_context);
+
+ uint32_t test_duration = get_timestamp_ms() - test_start;
+ printf("[AI_AT] ASR测试完成 - 耗时: %u毫秒\n", test_duration);
+
+ g_test_stats.tests_passed++;
+ return ERRCODE_SUCC;
+}
+
+/**
+ * @brief AT^AICHAT - 测试Chat服务
+ * 格式: AT^AICHAT=message
+ * 示例: AT^AICHAT=Hello AI
+ */
+static uint32_t at_ai_chat_test(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
+{
+ UNUSED(strCommonCmd);
+
+ printf("[AI_AT] 执行 AT^AICHAT - 详细测试Chat服务\n");
+
+ if (!g_ai_at_initialized) {
+ printf("[AI_AT] AI服务未初始化\n");
+ g_test_stats.tests_failed++;
+ return ERRCODE_FAIL;
+ }
+
+ g_test_stats.total_tests_run++;
+ g_test_stats.chat_tests_run++;
+
+ const char* message = AI_AT_DEMO_CHAT_MESSAGE;
+
+ if (para != NULL && paraLen > 0) {
+ uint8_t argv[AI_AT_MAX_ARGC][AI_AT_MAX_ARGV_LEN] = { 0 };
+ uint32_t argc = 0;
+
+ int ret = ConvertCmdToParam(para, paraLen, argv, &argc);
+ if (ret == AI_AT_SUCCESS && argc > 0 && strlen((char*)argv[0]) > 0) {
+ message = (char*)argv[0];
+ }
+ }
+
+ // 检查Chat连接状态
+ ai_connection_state_t state = ai_connection_manager_get_connection_state(AI_SERVICE_CHAT);
+ if (state != AI_CONN_STATE_CONNECTED) {
+ printf("[AI_AT] Chat服务未连接，状态: %d\n", state);
+ g_test_stats.tests_failed++;
+ return ERRCODE_FAIL;
+ }
+
+ char* session_id = generate_session_id();
+ uint32_t test_start = get_timestamp_ms();
+
+ printf("[AI_AT] 开始Chat测试 - 会话: %s\n", session_id);
+ printf("[AI_AT] 发送消息: %.100s%s\n", message, strlen(message) > 100 ? "..." : "");
+
+ // 发送聊天消息
+ ai_error_t ret = ai_chat_send_message(&g_ai_services_context, message, session_id);
+ if (ret != AI_OK) {
+ printf("[AI_AT] Chat消息发送失败: %d\n", ret);
+ g_test_stats.tests_failed++;
+ return ERRCODE_FAIL;
+ }
+
+ // 等待响应
+ printf("[AI_AT] 等待Chat响应...\n");
+#ifndef __TEST_MODE__
+ osDelay(1000); // 等待1秒
+#else
+ usleep(100000); // 测试模式等待100ms
+#endif
+
+ uint32_t test_duration = get_timestamp_ms() - test_start;
+ printf("[AI_AT] Chat测试完成 - 耗时: %u毫秒\n", test_duration);
+
+ g_test_stats.tests_passed++;
+ return ERRCODE_SUCC;
+}
+
+/**
+ * @brief AT^AITTS - 测试TTS服务
+ * 格式: AT^AITTS=text
+ * 示例: AT^AITTS=这是一个语音合成测试
+ */
+static uint32_t at_ai_tts_test(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
+{
+ UNUSED(strCommonCmd);
+
+ printf("[AI_AT] 执行 AT^AITTS - 详细测试TTS服务\n");
+
+ if (!g_ai_at_initialized) {
+ printf("[AI_AT] AI服务未初始化\n");
+ g_test_stats.tests_failed++;
+ return ERRCODE_FAIL;
+ }
+
+ g_test_stats.total_tests_run++;
+ g_test_stats.tts_tests_run++;
+
+ const char* text = AI_AT_DEMO_TTS_TEXT;
+
+ if (para != NULL && paraLen > 0) {
+ uint8_t argv[AI_AT_MAX_ARGC][AI_AT_MAX_ARGV_LEN] = { 0 };
+ uint32_t argc = 0;
+
+ int ret = ConvertCmdToParam(para, paraLen, argv, &argc);
+ if (ret == AI_AT_SUCCESS && argc > 0 && strlen((char*)argv[0]) > 0) {
+ text = (char*)argv[0];
+ }
+ }
+
+ // 检查TTS连接状态
+ ai_connection_state_t state = ai_connection_manager_get_connection_state(AI_SERVICE_TTS);
+ if (state != AI_CONN_STATE_CONNECTED) {
+ printf("[AI_AT] TTS服务未连接，状态: %d\n", state);
+ g_test_stats.tests_failed++;
+ return ERRCODE_FAIL;
+ }
+
+ char* session_id = generate_session_id();
+ uint32_t test_start = get_timestamp_ms();
+
+ printf("[AI_AT] 开始TTS测试 - 会话: %s\n", session_id);
+ printf("[AI_AT] 合成文本: %.100s%s\n", text, strlen(text) > 100 ? "..." : "");
+
+ // 启动TTS合成
+ ai_error_t ret = ai_tts_synthesize(&g_ai_services_context, text, session_id);
+ if (ret != AI_OK) {
+ printf("[AI_AT] TTS合成启动失败: %d\n", ret);
+ g_test_stats.tests_failed++;
+ return ERRCODE_FAIL;
+ }
+
+ // 等待合成完成
+ printf("[AI_AT] 等待TTS合成...\n");
+#ifndef __TEST_MODE__
+ osDelay(1500); // 等待1.5秒
+#else
+ usleep(150000); // 测试模式等待150ms
+#endif
+
+ uint32_t test_duration = get_timestamp_ms() - test_start;
+ printf("[AI_AT] TTS测试完成 - 耗时: %u毫秒\n", test_duration);
+
+ g_test_stats.tests_passed++;
+ return ERRCODE_SUCC;
+}
+
+/**
+ * @brief AT^AIMEMORY - 测试内存池
+ * 格式: AT^AIMEMORY=pool_type
+ * 示例: AT^AIMEMORY=2
+ */
+static uint32_t at_ai_memory_test(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
+{
+ UNUSED(strCommonCmd);
+
+ printf("[AI_AT] 执行 AT^AIMEMORY - 测试内存池\n");
+
+ if (!g_ai_at_initialized) {
+ printf("[AI_AT] AI服务未初始化\n");
+ return ERRCODE_FAIL;
+ }
+
+ ai_pool_type_t pool_type = AI_POOL_TYPE_NETWORK;
+
+ if (para != NULL && paraLen > 0) {
+ uint8_t argv[AI_AT_MAX_ARGC][AI_AT_MAX_ARGV_LEN] = { 0 };
+ uint32_t argc = 0;
+
+ int ret = ConvertCmdToParam(para, paraLen, argv, &argc);
+ if (ret == AI_AT_SUCCESS && argc > 0) {
+ int type = atoi((char*)argv[0]);
+ if (type >= 0 && type < AI_POOL_TYPE_COUNT) {
+ pool_type = (ai_pool_type_t)type;
+ } else {
+ printf("[AI_AT] 无效的内存池类型，范围: 0-%d\n", AI_POOL_TYPE_COUNT - 1);
+ return ERRCODE_FAIL;
+ }
+ }
+ }
+
+ // 测试内存分配和释放
+ ai_buffer_t* buffer = ai_memory_pool_alloc(pool_type, 512, AI_SERVICE_ASR);
+ if (buffer == NULL) {
+ printf("[AI_AT] 内存池 %d 分配失败\n", pool_type);
+ return ERRCODE_FAIL;
+ }
+
+ // 写入测试数据
+ memset(buffer->buffer, 0xAA, buffer->size);
+
+ // 获取内存统计
+ const ai_memory_stats_t* stats = ai_memory_pool_get_global_stats();
+
+ // 释放内存
+ ai_memory_pool_free(buffer);
+
+ printf("[AI_AT] 内存测试完成 - 池: %d, 分配: 512字节, 使用情况: %u/%u字节\n",
+ pool_type, stats->used_size, stats->total_size);
+
+ return ERRCODE_SUCC;
+}
+
+/**
+ * @brief AT^AIPERF - 性能测试
+ * 格式: AT^AIPERF
+ */
+static uint32_t at_ai_performance_test(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
+{
+ UNUSED(para);
+ UNUSED(paraLen);
+ UNUSED(strCommonCmd);
+
+ printf("[AI_AT] 执行 AT^AIPERF - 性能测试\n");
+
+ if (!g_ai_at_initialized) {
+ printf("[AI_AT] AI服务未初始化\n");
+ return ERRCODE_FAIL;
+ }
+
+ // 获取连接性能指标
+ const ai_connect_metrics_t* metrics = ai_connection_manager_get_metrics();
+
+ // 获取内存使用统计
+ const ai_memory_stats_t* mem_stats = ai_memory_pool_get_global_stats();
+
+ printf("[AI_AT] 性能指标:\n");
+ printf("[AI_AT] - 总连接数: %u\n", AI_SERVICE_COUNT);
+ printf("[AI_AT] - 总连接时间: %u毫秒\n", metrics->total_connect_time_ms);
+ printf("[AI_AT] - 内存效率: %.1f%%\n", (float)mem_stats->used_size * 100.0f / mem_stats->total_size);
+ printf("[AI_AT] - 碎片率: %u%%\n", mem_stats->fragmentation);
+
+ return ERRCODE_SUCC;
+}
+
+/**
+ * @brief AT^AIALLTEST - 运行所有服务的综合测试
+ * 格式: AT^AIALLTEST
+ */
+static uint32_t at_ai_all_test(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
+{
+ UNUSED(para);
+ UNUSED(paraLen);
+ UNUSED(strCommonCmd);
+
+ printf("[AI_AT] 执行 AT^AIALLTEST - 运行综合测试\n");
+
+ if (!g_ai_at_initialized) {
+ printf("[AI_AT] AI服务未初始化，请先执行 AT^AIINIT\n");
+ return ERRCODE_FAIL;
+ }
+
+ // 重置测试统计
+ memset(&g_test_stats, 0, sizeof(g_test_stats));
+ g_test_stats.test_start_time = get_timestamp_ms();
+
+ printf("[AI_AT] 开始综合测试...\n");
+
+ // 依次测试各个服务
+ printf("[AI_AT] === 测试ASR服务 ===\n");
+ at_ai_asr_test(NULL, 0, NULL);
+
+ printf("[AI_AT] === 测试Chat服务 ===\n");
+ at_ai_chat_test(NULL, 0, NULL);
+
+ printf("[AI_AT] === 测试TTS服务 ===\n");
+ at_ai_tts_test(NULL, 0, NULL);
+
+ // 等待所有异步操作完成
+ printf("[AI_AT] 等待所有测试完成...\n");
+#ifndef __TEST_MODE__
+ osDelay(2000); // 等待2秒
+#else
+ usleep(200000); // 测试模式等待200ms
+#endif
+
+ // 显示测试结果
+ uint32_t total_time = get_timestamp_ms() - g_test_stats.test_start_time;
+ printf("[AI_AT] === 综合测试完成 ===\n");
+ printf("[AI_AT] 总耗时: %u毫秒\n", total_time);
+ printf("[AI_AT] 总测试数: %u\n", g_test_stats.total_tests_run);
+ printf("[AI_AT] 成功: %u, 失败: %u\n", g_test_stats.tests_passed, g_test_stats.tests_failed);
+ printf("[AI_AT] ASR测试: %u, Chat测试: %u, TTS测试: %u\n",
+ g_test_stats.asr_tests_run, g_test_stats.chat_tests_run, g_test_stats.tts_tests_run);
+
+ if (g_test_stats.tests_failed == 0) {
+ printf("[AI_AT] ✅ 所有测试通过！\n");
+ return ERRCODE_SUCC;
+ } else {
+ printf("[AI_AT] ❌ 有 %u 个测试失败\n", g_test_stats.tests_failed);
+ return ERRCODE_FAIL;
+ }
+}
+
+/**
+ * @brief AT^AISTATS - 显示测试统计信息
+ * 格式: AT^AISTATS
+ */
+static uint32_t at_ai_stats(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
+{
+ UNUSED(para);
+ UNUSED(paraLen);
+ UNUSED(strCommonCmd);
+
+ printf("[AI_AT] 执行 AT^AISTATS - 显示测试统计\n");
+
+ printf("[AI_AT] === 测试统计信息 ===\n");
+ printf("[AI_AT] 测试开始时间: %u\n", g_test_stats.test_start_time);
+ printf("[AI_AT] 总测试数: %u\n", g_test_stats.total_tests_run);
+ printf("[AI_AT] 成功测试: %u\n", g_test_stats.tests_passed);
+ printf("[AI_AT] 失败测试: %u\n", g_test_stats.tests_failed);
+ printf("[AI_AT] ASR测试次数: %u\n", g_test_stats.asr_tests_run);
+ printf("[AI_AT] Chat测试次数: %u\n", g_test_stats.chat_tests_run);
+ printf("[AI_AT] TTS测试次数: %u\n", g_test_stats.tts_tests_run);
+
+ if (g_test_stats.total_tests_run > 0) {
+ float success_rate = (float)g_test_stats.tests_passed * 100.0f / g_test_stats.total_tests_run;
+ printf("[AI_AT] 成功率: %.1f%%\n", success_rate);
+ }
+
+ return ERRCODE_SUCC;
+}
+
+/**
+ * @brief AT^AICLEANUP - 清理AI服务
+ * 格式: AT^AICLEANUP
+ */
+static uint32_t at_ai_cleanup(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
+{
+ UNUSED(para);
+ UNUSED(paraLen);
+ UNUSED(strCommonCmd);
+
+ printf("[AI_AT] 执行 AT^AICLEANUP - 清理AI服务\n");
+
+ if (!g_ai_at_initialized) {
+ printf("[AI_AT] AI服务未初始化\n");
+ return ERRCODE_SUCC;
+ }
+
+ ai_services_destroy(&g_ai_services_context);
+ ai_connection_manager_destroy();
+ ai_memory_pool_destroy();
+
+ memset(&g_ai_services_context, 0, sizeof(g_ai_services_context));
+ memset(&g_test_stats, 0, sizeof(g_test_stats));
+ g_ai_at_initialized = false;
+ g_ai_session_counter = 0;
+
+ printf("[AI_AT] AI服务清理完成\n");
+
+ return ERRCODE_SUCC;
+}
+
+/* ================================ AT命令表定义 ================================ */
+
+static const at_cmd_table_t g_ai_cmd[] = {
+ { (char *)"AT^AIINIT", at_ai_init, (char *)"Initialize AI services" },
+ { (char *)"AT^AICONNECT", at_ai_connect, (char *)"Connect to AI services" },
+ { (char *)"AT^AISTATUS", at_ai_status, (char *)"Query AI service status" },
+ { (char *)"AT^AIASR", at_ai_asr_test, (char *)"duration_ms" },
+ { (char *)"AT^AICHAT", at_ai_chat_test, (char *)"message" },
+ { (char *)"AT^AITTS", at_ai_tts_test, (char *)"text" },
+ { (char *)"AT^AIMEMORY", at_ai_memory_test, (char *)"pool_type" },
+ { (char *)"AT^AIPERF", at_ai_performance_test, (char *)"Performance test" },
+ { (char *)"AT^AIALLTEST", at_ai_all_test, (char *)"Run comprehensive test" },
+ { (char *)"AT^AISTATS", at_ai_stats, (char *)"Show test statistics" },
+ { (char *)"AT^AICLEANUP", at_ai_cleanup, (char *)"Cleanup AI services" },
+};
+
+/* ================================ 公共接口 ================================ */
+
+/**
+ * @brief 获取AI AT命令表
+ * @param cmd_count 返回命令数量
+ * @return AT命令表指针
+ */
+at_cmd_table_t *get_ai_cmd_table(uint32_t *cmd_count)
+{
+ *cmd_count = ARRAY_COUNT(g_ai_cmd);
+ return (at_cmd_table_t *)g_ai_cmd;
+}
+
+#ifdef __TEST_MODE__
+/**
+ * @brief 测试模式主函数
+ */
+int main(void)
+{
+ printf("AI AT Command Integration Test (LiteOS AT System)\n");
+ printf("=================================================\n");
+
+ uint32_t cmd_count;
+ at_cmd_table_t *cmd_table = get_ai_cmd_table(&cmd_count);
+
+ printf("AI AT命令表包含 %u 个命令:\n", cmd_count);
+ for (uint32_t i = 0; i < cmd_count; i++) {
+ printf(" %u. %s - %s\n", i + 1, cmd_table[i].str_cmd, cmd_table[i].str_common);
+ }
+
+ printf("\n=== AI服务AT命令演示测试 ===\n");
+ printf("集成了ai_demo.c中的详细测试用例\n");
+
+ printf("\n1. 测试 AT^AIINIT - 初始化AI服务\n");
+ uint32_t result = at_ai_init(NULL, 0, NULL);
+ printf(" 结果: %s\n", result == ERRCODE_SUCC ? "✅ 成功" : "❌ 失败");
+
+ printf("\n2. 测试 AT^AICONNECT - 连接AI服务\n");
+ result = at_ai_connect(NULL, 0, NULL);
+ printf(" 结果: %s\n", result == ERRCODE_SUCC ? "✅ 成功" : "❌ 失败");
+
+ printf("\n3. 测试 AT^AISTATUS - 查询服务状态\n");
+ result = at_ai_status(NULL, 0, NULL);
+ printf(" 结果: %s\n", result == ERRCODE_SUCC ? "✅ 成功" : "❌ 失败");
+
+ printf("\n4. 测试 AT^AIALLTEST - 运行综合测试\n");
+ result = at_ai_all_test(NULL, 0, NULL);
+ printf(" 结果: %s\n", result == ERRCODE_SUCC ? "✅ 成功" : "❌ 失败");
+
+ printf("\n5. 测试 AT^AISTATS - 显示测试统计\n");
+ result = at_ai_stats(NULL, 0, NULL);
+ printf(" 结果: %s\n", result == ERRCODE_SUCC ? "✅ 成功" : "❌ 失败");
+
+ printf("\n6. 单独测试各个服务:\n");
+
+ printf("\n6.1 测试 AT^AIASR=3000 - ASR语音识别\n");
+ uint8_t asr_para[] = "3000";
+ result = at_ai_asr_test(asr_para, sizeof(asr_para) - 1, NULL);
+ printf(" 结果: %s\n", result == ERRCODE_SUCC ? "✅ 成功" : "❌ 失败");
+
+ printf("\n6.2 测试 AT^AICHAT - Chat对话服务\n");
+ uint8_t chat_para[] = "你好，这是AT命令测试";
+ result = at_ai_chat_test(chat_para, sizeof(chat_para) - 1, NULL);
+ printf(" 结果: %s\n", result == ERRCODE_SUCC ? "✅ 成功" : "❌ 失败");
+
+ printf("\n6.3 测试 AT^AITTS - TTS语音合成\n");
+ uint8_t tts_para[] = "这是语音合成测试";
+ result = at_ai_tts_test(tts_para, sizeof(tts_para) - 1, NULL);
+ printf(" 结果: %s\n", result == ERRCODE_SUCC ? "✅ 成功" : "❌ 失败");
+
+ printf("\n7. 测试 AT^AIMEMORY=2 - 内存池测试\n");
+ uint8_t mem_para[] = "2";
+ result = at_ai_memory_test(mem_para, sizeof(mem_para) - 1, NULL);
+ printf(" 结果: %s\n", result == ERRCODE_SUCC ? "✅ 成功" : "❌ 失败");
+
+ printf("\n8. 测试 AT^AIPERF - 性能测试\n");
+ result = at_ai_performance_test(NULL, 0, NULL);
+ printf(" 结果: %s\n", result == ERRCODE_SUCC ? "✅ 成功" : "❌ 失败");
+
+ printf("\n9. 最终统计和清理\n");
+ result = at_ai_stats(NULL, 0, NULL);
+ printf(" 统计结果: %s\n", result == ERRCODE_SUCC ? "✅ 成功" : "❌ 失败");
+
+ printf("\n10. 测试 AT^AICLEANUP - 清理AI服务\n");
+ result = at_ai_cleanup(NULL, 0, NULL);
+ printf(" 结果: %s\n", result == ERRCODE_SUCC ? "✅ 成功" : "❌ 失败");
+
+ printf("\n=== AI AT命令集成测试完成 ===\n");
+ printf("✓ 所有命令表注册成功\n");
+ printf("✓ 命令处理函数正常工作\n");
+ printf("✓ 可以集成到LiteOS AT系统中\n");
+
+ return 0;
+}
+#endif
+
+#ifdef __cplusplus
+#if __cplusplus
+}
+#endif /* __cplusplus */
+#endif /* __cplusplus */
\ No newline at end of file
+++ /dev/null
-/*
- * Copyright (c) CompanyNameMagicTag. 2023-2023. All rights reserved.
- * Description: AI Service AT Command Test Module
- * Author: AI Development Team
- * Create: 2024-12-28
- */
-
-#include "ai_at_test.h"
-#include "at_cmd_api.h"
-#include "cat1_ws.h"
-#include "ai_media.h"
-#include <stdio.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* ==================== 宏定义 ==================== */
-
-#define AI_AT_MAX_ARGC 8
-#define AI_AT_MAX_ARGV_LEN 256
-#define AI_AT_SUCCESS 0
-#define AI_AT_FAILED (-1)
-
-/* ==================== 内部函数声明 ==================== */
-
-static int ai_convert_cmd_to_param(uint8_t *para, uint32_t paraLen,
- uint8_t argv[AI_AT_MAX_ARGC][AI_AT_MAX_ARGV_LEN], uint32_t* argc);
-
-/* ==================== 工具函数 ==================== */
-
-/**
- * @brief 将AT命令参数字符串转换为参数数组
- * @param para 输入参数字符串
- * @param paraLen 参数字符串长度
- * @param argv 输出参数数组
- * @param argc 输出参数个数
- * @return 0成功，-1失败
- */
-static int ai_convert_cmd_to_param(uint8_t *para, uint32_t paraLen,
- uint8_t argv[AI_AT_MAX_ARGC][AI_AT_MAX_ARGV_LEN], uint32_t* argc)
-{
- uint32_t pos = 0;
- *argc = 0;
-
- for (uint32_t i = 0; i < paraLen; i++) {
- if ((para[i] == ' ' || para[i] == ',' || para[i] == '\n') && pos != 0) {
- argv[*argc][pos] = '\0';
- *argc += 1;
- pos = 0;
- if (*argc >= AI_AT_MAX_ARGC) {
- return AI_AT_FAILED;
- }
- } else if (para[i] != ' ' && para[i] != ',' && para[i] != '\n') {
- argv[*argc][pos] = para[i];
- pos++;
- if (pos >= AI_AT_MAX_ARGV_LEN) {
- return AI_AT_FAILED;
- }
- }
- }
- if (pos != 0) {
- argv[*argc][pos] = '\0';
- *argc += 1;
- }
-
- return AI_AT_SUCCESS;
-}
-
-/* ==================== ASR 测试命令 ==================== */
-
-/**
- * @brief ASR服务启动AT命令处理函数
- * 格式: AT^ASRSTART
- * 无参数
- */
-static uint32_t at_asr_start(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
-{
- UNUSED(para);
- UNUSED(paraLen);
- UNUSED(strCommonCmd);
-
- printf("[AI_AT] Starting ASR service...\n");
-
- uapi_start_asr();
-
- printf("[AI_AT] ASR service start command sent\n");
- return ERRCODE_SUCC;
-}
-
-/**
- * @brief ASR服务停止AT命令处理函数
- * 格式: AT^ASRSTOP
- * 无参数
- */
-static uint32_t at_asr_stop(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
-{
- UNUSED(para);
- UNUSED(paraLen);
- UNUSED(strCommonCmd);
-
- printf("[AI_AT] Stopping ASR service...\n");
-
- uapi_stop_asr();
-
- printf("[AI_AT] ASR service stop command sent\n");
- return ERRCODE_SUCC;
-}
-
-/**
- * @brief ASR录音测试AT命令处理函数
- * 格式: AT^ASRRECORDTEST
- * 无参数
- */
-static uint32_t at_asr_record_test(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
-{
- UNUSED(para);
- UNUSED(paraLen);
- UNUSED(strCommonCmd);
-
- printf("[AI_AT] Starting ASR record test...\n");
-
- asr_record_test();
-
- printf("[AI_AT] ASR record test completed\n");
- return ERRCODE_SUCC;
-}
-
-/**
- * @brief ASR任务启动AT命令处理函数
- * 格式: AT^ASRTASKSTART
- * 无参数
- */
-static uint32_t at_asr_task_start(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
-{
- UNUSED(para);
- UNUSED(paraLen);
- UNUSED(strCommonCmd);
-
- printf("[AI_AT] Starting ASR task...\n");
-
- uapi_start_asr_task();
-
- printf("[AI_AT] ASR task start command sent\n");
- return ERRCODE_SUCC;
-}
-
-/* ==================== TTS 测试命令 ==================== */
-
-/**
- * @brief TTS服务启动AT命令处理函数
- * 格式: AT^TTSSTART
- * 无参数
- */
-static uint32_t at_tts_start(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
-{
- UNUSED(para);
- UNUSED(paraLen);
- UNUSED(strCommonCmd);
-
- printf("[AI_AT] Starting TTS service...\n");
-
- uapi_start_tts();
-
- printf("[AI_AT] TTS service start command sent\n");
- return ERRCODE_SUCC;
-}
-
-/**
- * @brief TTS服务停止AT命令处理函数
- * 格式: AT^TTSSTOP
- * 无参数
- */
-static uint32_t at_tts_stop(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
-{
- UNUSED(para);
- UNUSED(paraLen);
- UNUSED(strCommonCmd);
-
- printf("[AI_AT] Stopping TTS service...\n");
-
- uapi_stop_tts();
-
- printf("[AI_AT] TTS service stop command sent\n");
- return ERRCODE_SUCC;
-}
-
-/**
- * @brief TTS单次文本转语音AT命令处理函数
- * 格式: AT^TTSSAY=text
- * 参数: text - 要转换为语音的文本
- */
-static uint32_t at_tts_say(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
-{
- UNUSED(strCommonCmd);
-
- if (para == NULL || paraLen == 0) {
- printf("[AI_AT] TTS text parameter is required\n");
- return ERRCODE_FAIL;
- }
-
- // 确保文本以null结尾
- char *text = (char*)malloc(paraLen + 1);
- if (text == NULL) {
- printf("[AI_AT] Failed to allocate memory for TTS text\n");
- return ERRCODE_FAIL;
- }
-
- memcpy(text, para, paraLen);
- text[paraLen] = '\0';
-
- printf("[AI_AT] TTS converting text to speech: %s\n", text);
-
- bool result = uapi_start_tts_single_txt(text);
-
- free(text);
-
- if (result) {
- printf("[AI_AT] TTS text conversion started successfully\n");
- return ERRCODE_SUCC;
- } else {
- printf("[AI_AT] TTS text conversion failed\n");
- return ERRCODE_FAIL;
- }
-}
-
-/* ==================== Chat 测试命令 ==================== */
-
-/**
- * @brief Chat消息发送AT命令处理函数
- * 格式: AT^CHATSEND=type,message
- * 参数: type - 消息类型 (0-文本消息)
- * message - 要发送的消息内容
- */
-static uint32_t at_chat_send(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
-{
- UNUSED(strCommonCmd);
-
- uint8_t argv[AI_AT_MAX_ARGC][AI_AT_MAX_ARGV_LEN] = { 0 };
- uint32_t argc = 0;
-
- int ret = ai_convert_cmd_to_param(para, paraLen, argv, &argc);
- if (ret != AI_AT_SUCCESS) {
- printf("[AI_AT] Chat command parameter conversion failed\n");
- return ERRCODE_FAIL;
- }
-
- if (argc != 2) {
- printf("[AI_AT] Chat command requires 2 parameters: type,message\n");
- printf("Usage: AT^CHATSEND=0,Hello AI\n");
- return ERRCODE_FAIL;
- }
-
- uint8_t type = (uint8_t)atoi((char*)argv[0]);
- char *message = (char*)argv[1];
-
- printf("[AI_AT] Sending chat message (type=%d): %s\n", type, message);
-
- bool result = send_ai_txt(type, message);
-
- if (result) {
- printf("[AI_AT] Chat message sent successfully\n");
- return ERRCODE_SUCC;
- } else {
- printf("[AI_AT] Chat message send failed\n");
- return ERRCODE_FAIL;
- }
-}
-
-/* ==================== AI Media 测试命令 ==================== */
-
-/**
- * @brief AI录音启动AT命令处理函数
- * 格式: AT^AIRECORDSTART=format
- * 参数: format - 音频格式 ("pcm", "mp3", "opus")
- */
-static uint32_t at_ai_record_start(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
-{
- UNUSED(strCommonCmd);
-
- uint8_t *format = (uint8_t*)"pcm"; // 默认格式
-
- if (para != NULL && paraLen > 0) {
- // 使用用户指定的格式
- format = para;
- // 确保字符串以null结尾
- if (para[paraLen - 1] != '\0') {
- char *temp_format = (char*)malloc(paraLen + 1);
- if (temp_format != NULL) {
- memcpy(temp_format, para, paraLen);
- temp_format[paraLen] = '\0';
- format = (uint8_t*)temp_format;
- }
- }
- }
-
- printf("[AI_AT] Starting AI media recording with format: %s\n", (char*)format);
-
- ai_media_record_start(format);
-
- // 检查录音状态
- if (ai_media_get_record_status() == 1) {
- printf("[AI_AT] AI media recording started successfully\n");
-
- // 如果分配了临时内存，释放它
- if (para != NULL && paraLen > 0 && para[paraLen - 1] != '\0') {
- free((char*)format);
- }
-
- return ERRCODE_SUCC;
- } else {
- printf("[AI_AT] AI media recording start failed\n");
-
- // 如果分配了临时内存，释放它
- if (para != NULL && paraLen > 0 && para[paraLen - 1] != '\0') {
- free((char*)format);
- }
-
- return ERRCODE_FAIL;
- }
-}
-
-/**
- * @brief AI录音停止AT命令处理函数
- * 格式: AT^AIRECORDSTOP
- * 无参数
- */
-static uint32_t at_ai_record_stop(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
-{
- UNUSED(para);
- UNUSED(paraLen);
- UNUSED(strCommonCmd);
-
- printf("[AI_AT] Stopping AI media recording...\n");
-
- ai_media_record_stop();
-
- // 检查录音状态
- if (ai_media_get_record_status() == 0) {
- printf("[AI_AT] AI media recording stopped successfully\n");
- return ERRCODE_SUCC;
- } else {
- printf("[AI_AT] AI media recording stop failed\n");
- return ERRCODE_FAIL;
- }
-}
-
-/**
- * @brief AI播放启动AT命令处理函数
- * 格式: AT^AIPLAYSTART=format
- * 参数: format - 音频格式 ("pcm", "mp3", "opus")
- */
-static uint32_t at_ai_play_start(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
-{
- UNUSED(strCommonCmd);
-
- uint8_t *format = (uint8_t*)"pcm"; // 默认格式
-
- if (para != NULL && paraLen > 0) {
- // 使用用户指定的格式
- format = para;
- // 确保字符串以null结尾
- if (para[paraLen - 1] != '\0') {
- char *temp_format = (char*)malloc(paraLen + 1);
- if (temp_format != NULL) {
- memcpy(temp_format, para, paraLen);
- temp_format[paraLen] = '\0';
- format = (uint8_t*)temp_format;
- }
- }
- }
-
- printf("[AI_AT] Starting AI media playback with format: %s\n", (char*)format);
-
- ai_media_play_start(format);
-
- // 检查播放状态
- if (ai_media_get_play_status() == 1) {
- printf("[AI_AT] AI media playback started successfully\n");
-
- // 如果分配了临时内存，释放它
- if (para != NULL && paraLen > 0 && para[paraLen - 1] != '\0') {
- free((char*)format);
- }
-
- return ERRCODE_SUCC;
- } else {
- printf("[AI_AT] AI media playback start failed\n");
-
- // 如果分配了临时内存，释放它
- if (para != NULL && paraLen > 0 && para[paraLen - 1] != '\0') {
- free((char*)format);
- }
-
- return ERRCODE_FAIL;
- }
-}
-
-/**
- * @brief AI播放停止AT命令处理函数
- * 格式: AT^AIPLAYSTOP
- * 无参数
- */
-static uint32_t at_ai_play_stop(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
-{
- UNUSED(para);
- UNUSED(paraLen);
- UNUSED(strCommonCmd);
-
- printf("[AI_AT] Stopping AI media playback...\n");
-
- ai_media_play_stop();
-
- // 检查播放状态
- if (ai_media_get_play_status() == 0) {
- printf("[AI_AT] AI media playback stopped successfully\n");
- return ERRCODE_SUCC;
- } else {
- printf("[AI_AT] AI media playback stop failed\n");
- return ERRCODE_FAIL;
- }
-}
-
-/**
- * @brief AI媒体状态查询AT命令处理函数
- * 格式: AT^AIMEDIASTATUS
- * 无参数
- */
-static uint32_t at_ai_media_status(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
-{
- UNUSED(para);
- UNUSED(paraLen);
- UNUSED(strCommonCmd);
-
- printf("[AI_AT] AI Media Status Query\n");
-
- uint8_t record_status = ai_media_get_record_status();
- uint8_t play_status = ai_media_get_play_status();
-
- printf("[AI_AT] Recording Status: %s\n", record_status ? "Active" : "Stopped");
- printf("[AI_AT] Playback Status: %s\n", play_status ? "Active" : "Stopped");
-
- return ERRCODE_SUCC;
-}
-
-/* ==================== AI 综合测试命令 ==================== */
-
-/**
- * @brief AI服务状态查询AT命令处理函数
- * 格式: AT^AISTATUS
- * 无参数
- */
-static uint32_t at_ai_status(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
-{
- UNUSED(para);
- UNUSED(paraLen);
- UNUSED(strCommonCmd);
-
- printf("[AI_AT] AI Services Status Query\n");
-
- // 查询各个服务的初始化状态
- uint8_t asr_init = get_ai_asr_service_init_flag();
- uint8_t chat_init = get_ai_chat_service_init_flag();
- uint8_t tts_init = get_ai_tts_server_init_flag();
-
- printf("[AI_AT] ASR Service: %s\n", asr_init ? "Initialized" : "Not Initialized");
- printf("[AI_AT] Chat Service: %s\n", chat_init ? "Initialized" : "Not Initialized");
- printf("[AI_AT] TTS Service: %s\n", tts_init ? "Initialized" : "Not Initialized");
-
- // 查询媒体服务状态
- uint8_t record_status = ai_media_get_record_status();
- uint8_t play_status = ai_media_get_play_status();
-
- printf("[AI_AT] Media Recording: %s\n", record_status ? "Active" : "Stopped");
- printf("[AI_AT] Media Playback: %s\n", play_status ? "Active" : "Stopped");
-
- return ERRCODE_SUCC;
-}
-
-/**
- * @brief AI完整测试流程AT命令处理函数
- * 格式: AT^AITEST=duration
- * 参数: duration - 测试持续时间(秒)，默认10秒
- */
-static uint32_t at_ai_full_test(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
-{
- UNUSED(strCommonCmd);
-
- uint32_t duration = 10; // 默认10秒
-
- if (para != NULL && paraLen > 0) {
- uint8_t argv[AI_AT_MAX_ARGC][AI_AT_MAX_ARGV_LEN] = { 0 };
- uint32_t argc = 0;
-
- int ret = ai_convert_cmd_to_param(para, paraLen, argv, &argc);
- if (ret == AI_AT_SUCCESS && argc >= 1) {
- duration = (uint32_t)atoi((char*)argv[0]);
- if (duration == 0) {
- duration = 10; // 防止0值
- }
- }
- }
-
- printf("[AI_AT] Starting AI full test for %u seconds...\n", duration);
-
- // 1. 启动ASR服务
- printf("[AI_AT] Step 1: Starting ASR service\n");
- uapi_start_asr();
-
- // 2. 启动录音
- printf("[AI_AT] Step 2: Starting recording\n");
- ai_media_record_start((uint8_t*)"pcm");
-
- // 3. 等待指定时间
- printf("[AI_AT] Step 3: Recording for %u seconds...\n", duration);
- // 这里应该使用系统延时函数，简化处理
- for (uint32_t i = 0; i < duration; i++) {
- printf("[AI_AT] Recording... %u/%u seconds\n", i + 1, duration);
- // 实际应用中应该使用 osDelay 或类似函数
- // osDelay(1000); // 1秒延时
- }
-
- // 4. 停止录音
- printf("[AI_AT] Step 4: Stopping recording\n");
- ai_media_record_stop();
-
- // 5. 停止ASR服务
- printf("[AI_AT] Step 5: Stopping ASR service\n");
- uapi_stop_asr();
-
- // 6. 测试TTS
- printf("[AI_AT] Step 6: Testing TTS\n");
- uapi_start_tts();
- bool tts_result = uapi_start_tts_single_txt("AI测试完成");
- if (tts_result) {
- printf("[AI_AT] TTS test successful\n");
- } else {
- printf("[AI_AT] TTS test failed\n");
- }
-
- printf("[AI_AT] AI full test completed\n");
- return ERRCODE_SUCC;
-}
-
-/* ==================== AT命令表定义 ==================== */
-
-static const at_cmd_table_t g_ai_at_cmd_table[] = {
- // ASR 相关命令
- { (char *)"AT^ASRSTART", at_asr_start, (char *)"Start ASR service" },
- { (char *)"AT^ASRSTOP", at_asr_stop, (char *)"Stop ASR service" },
- { (char *)"AT^ASRRECORDTEST", at_asr_record_test, (char *)"ASR record test" },
- { (char *)"AT^ASRTASKSTART", at_asr_task_start, (char *)"Start ASR task" },
-
- // TTS 相关命令
- { (char *)"AT^TTSSTART", at_tts_start, (char *)"Start TTS service" },
- { (char *)"AT^TTSSTOP", at_tts_stop, (char *)"Stop TTS service" },
- { (char *)"AT^TTSSAY", at_tts_say, (char *)"text" },
-
- // Chat 相关命令
- { (char *)"AT^CHATSEND", at_chat_send, (char *)"type,message" },
-
- // AI Media 相关命令
- { (char *)"AT^AIRECORDSTART", at_ai_record_start, (char *)"format" },
- { (char *)"AT^AIRECORDSTOP", at_ai_record_stop, (char *)"Stop AI recording" },
- { (char *)"AT^AIPLAYSTART", at_ai_play_start, (char *)"format" },
- { (char *)"AT^AIPLAYSTOP", at_ai_play_stop, (char *)"Stop AI playback" },
- { (char *)"AT^AIMEDIASTATUS", at_ai_media_status, (char *)"Query AI media status" },
-
- // AI 综合命令
- { (char *)"AT^AISTATUS", at_ai_status, (char *)"Query AI services status" },
- { (char *)"AT^AITEST", at_ai_full_test, (char *)"duration" },
-};
-
-/* ==================== 公共接口函数 ==================== */
-
-/**
- * @brief 获取AI AT命令表
- * @param cmd_count 输出命令数量
- * @return AT命令表指针
- */
-at_cmd_table_t *get_ai_at_cmd_table(uint32_t *cmd_count)
-{
- if (cmd_count != NULL) {
- *cmd_count = sizeof(g_ai_at_cmd_table) / sizeof(g_ai_at_cmd_table[0]);
- }
- return (at_cmd_table_t *)g_ai_at_cmd_table;
-}
-
-#ifdef __cplusplus
-}
-#endif
\ No newline at end of file
+++ /dev/null
-/*
- * Copyright (c) CompanyNameMagicTag. 2023-2023. All rights reserved.
- * Description: AI Service AT Command Test Module Header
- * Author: AI Development Team
- * Create: 2024-12-28
- */
-
-#ifndef AI_AT_TEST_H
-#define AI_AT_TEST_H
-
-#include <stdint.h>
-#include "at_cmd_api.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* ==================== 宏定义 ==================== */
-
-#ifndef UNUSED
-#define UNUSED(x) ((void)(x))
-#endif
-
-#ifndef ERRCODE_SUCC
-#define ERRCODE_SUCC 0
-#endif
-
-#ifndef ERRCODE_FAIL
-#define ERRCODE_FAIL (-1)
-#endif
-
-/* ==================== 类型定义 ==================== */
-
-/**
- * @brief AT命令表结构体
- */
-typedef struct {
- char *at_cmd_name; // AT命令名称
- uint32_t (*at_cmd_func)(uint8_t *para, uint32_t paraLen, char *strCommonCmd); // 命令处理函数
- char *param_name; // 参数说明
-} at_cmd_table_t;
-
-/* ==================== 函数声明 ==================== */
-
-/**
- * @brief 获取AI AT命令表
- * @param cmd_count 输出命令数量指针
- * @return AT命令表指针
- */
-at_cmd_table_t *get_ai_at_cmd_table(uint32_t *cmd_count);
-
-/**
- * @brief 初始化AI AT命令模块
- * @return 0成功，-1失败
- */
-int ai_at_test_init(void);
-
-/**
- * @brief 反初始化AI AT命令模块
- */
-void ai_at_test_deinit(void);
-
-/* ==================== AI服务状态查询函数声明 ==================== */
-
-/**
- * @brief 获取ASR服务初始化标志
- * @return 初始化状态 (0: 未初始化, 1: 已初始化)
- */
-uint8_t get_ai_asr_service_init_flag(void);
-
-/**
- * @brief 获取Chat服务初始化标志
- * @return 初始化状态 (0: 未初始化, 1: 已初始化)
- */
-uint8_t get_ai_chat_service_init_flag(void);
-
-/**
- * @brief 获取TTS服务初始化标志
- * @return 初始化状态 (0: 未初始化, 1: 已初始化)
- */
-uint8_t get_ai_tts_server_init_flag(void);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* AI_AT_TEST_H */
\ No newline at end of file
+++ /dev/null
-/*
- * Copyright (c) CompanyNameMagicTag. 2023-2023. All rights reserved.
- * Description: AI AT Test Commands Usage Example
- * Author: AI Development Team
- * Create: 2024-12-28
- */
-
-#include "ai_at_test.h"
-#include <stdio.h>
-#include <string.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* ==================== 示例函数 ==================== */
-
-/**
- * @brief 演示基本ASR测试流程
- */
-void example_asr_basic_test(void)
-{
- printf("\n========== ASR Basic Test Example ==========\n");
-
- // 1. 启动ASR服务
- printf("1. Starting ASR service...\n");
- // 模拟AT命令: AT^ASRSTART
-
- // 2. 启动ASR任务
- printf("2. Starting ASR task...\n");
- // 模拟AT命令: AT^ASRTASKSTART
-
- // 3. 进行录音测试
- printf("3. Running ASR record test...\n");
- // 模拟AT命令: AT^ASRRECORDTEST
-
- // 4. 停止ASR服务
- printf("4. Stopping ASR service...\n");
- // 模拟AT命令: AT^ASRSTOP
-
- printf("ASR basic test completed!\n");
-}
-
-/**
- * @brief 演示基本TTS测试流程
- */
-void example_tts_basic_test(void)
-{
- printf("\n========== TTS Basic Test Example ==========\n");
-
- // 1. 启动TTS服务
- printf("1. Starting TTS service...\n");
- // 模拟AT命令: AT^TTSSTART
-
- // 2. 文本转语音测试
- printf("2. Converting text to speech...\n");
- // 模拟AT命令: AT^TTSSAY=Hello, this is a TTS test
-
- // 3. 停止TTS服务
- printf("3. Stopping TTS service...\n");
- // 模拟AT命令: AT^TTSSTOP
-
- printf("TTS basic test completed!\n");
-}
-
-/**
- * @brief 演示Chat测试流程
- */
-void example_chat_test(void)
-{
- printf("\n========== Chat Test Example ==========\n");
-
- // 1. 发送文本消息
- printf("1. Sending chat message...\n");
- // 模拟AT命令: AT^CHATSEND=0,How are you today?
-
- // 2. 发送另一条消息
- printf("2. Sending another chat message...\n");
- // 模拟AT命令: AT^CHATSEND=0,What's the weather like?
-
- printf("Chat test completed!\n");
-}
-
-/**
- * @brief 演示AI媒体服务测试流程
- */
-void example_ai_media_test(void)
-{
- printf("\n========== AI Media Test Example ==========\n");
-
- // 1. 启动录音
- printf("1. Starting AI recording with PCM format...\n");
- // 模拟AT命令: AT^AIRECORDSTART=pcm
-
- // 2. 查询媒体状态
- printf("2. Checking AI media status...\n");
- // 模拟AT命令: AT^AIMEDIASTATUS
-
- // 3. 停止录音
- printf("3. Stopping AI recording...\n");
- // 模拟AT命令: AT^AIRECORDSTOP
-
- // 4. 启动播放
- printf("4. Starting AI playback with PCM format...\n");
- // 模拟AT命令: AT^AIPLAYSTART=pcm
-
- // 5. 停止播放
- printf("5. Stopping AI playback...\n");
- // 模拟AT命令: AT^AIPLAYSTOP
-
- printf("AI media test completed!\n");
-}
-
-/**
- * @brief 演示完整AI测试流程
- */
-void example_full_ai_test(void)
-{
- printf("\n========== Full AI Test Example ==========\n");
-
- // 1. 查询AI服务状态
- printf("1. Checking AI services status...\n");
- // 模拟AT命令: AT^AISTATUS
-
- // 2. 运行完整AI测试（10秒）
- printf("2. Running full AI test for 10 seconds...\n");
- // 模拟AT命令: AT^AITEST=10
-
- // 3. 再次查询状态
- printf("3. Checking AI services status again...\n");
- // 模拟AT命令: AT^AISTATUS
-
- printf("Full AI test completed!\n");
-}
-
-/**
- * @brief 演示语音对话流程
- */
-void example_voice_conversation_test(void)
-{
- printf("\n========== Voice Conversation Test Example ==========\n");
-
- // 1. 启动ASR和录音
- printf("1. Starting ASR and recording...\n");
- // AT^ASRSTART
- // AT^AIRECORDSTART=pcm
-
- // 2. 模拟录音5秒
- printf("2. Recording for 5 seconds...\n");
- // (等待录音)
-
- // 3. 停止录音
- printf("3. Stopping recording...\n");
- // AT^AIRECORDSTOP
-
- // 4. 发送识别结果到Chat
- printf("4. Sending ASR result to Chat...\n");
- // AT^CHATSEND=0,User said something
-
- // 5. 启动TTS播放回复
- printf("5. Starting TTS for response...\n");
- // AT^TTSSTART
- // AT^TTSSAY=AI response to user
-
- // 6. 清理
- printf("6. Cleaning up services...\n");
- // AT^ASRSTOP
- // AT^TTSSTOP
-
- printf("Voice conversation test completed!\n");
-}
-
-/**
- * @brief 打印所有可用的AI AT命令
- */
-void example_print_available_commands(void)
-{
- printf("\n========== Available AI AT Commands ==========\n");
-
- printf("ASR Commands:\n");
- printf(" AT^ASRSTART - Start ASR service\n");
- printf(" AT^ASRSTOP - Stop ASR service\n");
- printf(" AT^ASRRECORDTEST - Run ASR record test\n");
- printf(" AT^ASRTASKSTART - Start ASR task\n");
- printf("\n");
-
- printf("TTS Commands:\n");
- printf(" AT^TTSSTART - Start TTS service\n");
- printf(" AT^TTSSTOP - Stop TTS service\n");
- printf(" AT^TTSSAY=text - Convert text to speech\n");
- printf("\n");
-
- printf("Chat Commands:\n");
- printf(" AT^CHATSEND=type,message - Send chat message\n");
- printf("\n");
-
- printf("AI Media Commands:\n");
- printf(" AT^AIRECORDSTART=format - Start AI recording\n");
- printf(" AT^AIRECORDSTOP - Stop AI recording\n");
- printf(" AT^AIPLAYSTART=format - Start AI playback\n");
- printf(" AT^AIPLAYSTOP - Stop AI playback\n");
- printf(" AT^AIMEDIASTATUS - Query AI media status\n");
- printf("\n");
-
- printf("General AI Commands:\n");
- printf(" AT^AISTATUS - Query AI services status\n");
- printf(" AT^AITEST=duration - Run full AI test\n");
- printf("\n");
-
- printf("Format options: pcm, mp3, opus\n");
- printf("Message types: 0 (text message)\n");
-}
-
-/**
- * @brief 主示例函数
- */
-int ai_at_test_example_main(void)
-{
- printf("========== AI AT Test Examples ==========\n");
-
- // 初始化AI AT测试模块
- if (ai_at_test_init() != 0) {
- printf("Failed to initialize AI AT test module\n");
- return -1;
- }
-
- // 打印可用命令
- example_print_available_commands();
-
- // 运行各种测试示例
- example_asr_basic_test();
- example_tts_basic_test();
- example_chat_test();
- example_ai_media_test();
- example_full_ai_test();
- example_voice_conversation_test();
-
- // 反初始化
- ai_at_test_deinit();
-
- printf("\n========== All AI AT Test Examples Completed ==========\n");
- return 0;
-}
-
-/**
- * @brief 测试特定AT命令的示例
- */
-void example_test_specific_command(void)
-{
- printf("\n========== Testing Specific AT Commands ==========\n");
-
- uint32_t cmd_count;
- at_cmd_table_t *cmd_table = get_ai_at_cmd_table(&cmd_count);
-
- if (cmd_table != NULL) {
- printf("Found %u AI AT commands:\n", cmd_count);
- for (uint32_t i = 0; i < cmd_count; i++) {
- printf(" [%u] %s - %s\n", i + 1,
- cmd_table[i].at_cmd_name,
- cmd_table[i].param_name);
- }
-
- // 示例：测试第一个命令
- if (cmd_count > 0) {
- printf("\nTesting first command: %s\n", cmd_table[0].at_cmd_name);
- // 这里可以调用具体的命令处理函数进行测试
- // cmd_table[0].at_cmd_func(NULL, 0, NULL);
- }
- } else {
- printf("Failed to get AI AT command table\n");
- }
-}
-
-#ifdef __cplusplus
-}
-#endif
\ No newline at end of file
--- /dev/null
+/**
+ * @file ai_demo.c
+ * @brief AI服务演示程序 - LiteOS-M优化版v2
+ * @version 2.0
+ * @date 2024-01-20
+ *
+ * 演示功能：
+ * - AI服务初始化和配置
+ * - 多连接管理和状态监控
+ * - ASR语音识别演示
+ * - Chat对话服务演示
+ * - TTS语音合成演示
+ * - AT指令测试接口
+ */
+
+#include "ai_connection_manager.h"
+#include "ai_memory_pool.h"
+#include "ai_services.h"
+#include "ai_at_commands.h"
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <time.h>
+
+#ifndef __TEST_MODE__
+#include "wearable_log.h"
+#include "dev_authentication.h"
+#define DEMO_LOG_TAG "AI_DEMO"
+#define DEMO_LOGI(fmt, ...) WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] " fmt, DEMO_LOG_TAG, ##__VA_ARGS__)
+#define DEMO_LOGE(fmt, ...) WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] " fmt, DEMO_LOG_TAG, ##__VA_ARGS__)
+#define DEMO_LOGW(fmt, ...) WEARABLE_LOGW(WEARABLE_LOG_MODULE_APP, "[%s] " fmt, DEMO_LOG_TAG, ##__VA_ARGS__)
+#else
+#define DEMO_LOGI(fmt, ...) printf("[AI_DEMO] " fmt "\n", ##__VA_ARGS__)
+#define DEMO_LOGE(fmt, ...) printf("[AI_DEMO] ERROR: " fmt "\n", ##__VA_ARGS__)
+#define DEMO_LOGW(fmt, ...) printf("[AI_DEMO] WARN: " fmt "\n", ##__VA_ARGS__)
+#endif
+
+/* ================================ 演示配置 ================================ */
+
+#define DEMO_ASR_URL "ws://amp.raisound.com/asr/ws"
+#define DEMO_CHAT_URL "ws://amp.raisound.com/chat/ws"
+#define DEMO_TTS_URL "ws://amp.raisound.com/tts/ws"
+
+#define DEMO_AUDIO_DATA_SIZE 1024 // 演示音频数据大小
+#define DEMO_CHAT_MESSAGE "你好，我是AI助手演示程序"
+#define DEMO_TTS_TEXT "欢迎使用AI语音服务"
+
+/* ================================ 全局变量 ================================ */
+
+static ai_services_context_t g_demo_services = {0};
+static bool g_demo_initialized = false;
+static bool g_demo_running = false;
+
+/* 演示统计信息 */
+static struct {
+ uint32_t asr_results_received;
+ uint32_t chat_responses_received;
+ uint32_t tts_results_received;
+ uint32_t total_errors;
+ uint32_t demo_start_time;
+} g_demo_stats = {0};
+
+/* ================================ 回调函数声明 ================================ */
+
+static void demo_connection_event_callback(const ai_event_t *event, void *user_data);
+static void demo_asr_result_callback(const asr_result_t *result, void *user_data);
+static void demo_asr_error_callback(int error_code, const char *error_msg, void *user_data);
+static void demo_asr_state_callback(asr_state_t old_state, asr_state_t new_state, void *user_data);
+static void demo_chat_response_callback(const chat_message_t *message, void *user_data);
+static void demo_chat_error_callback(int error_code, const char *error_msg, void *user_data);
+static void demo_chat_state_callback(chat_state_t old_state, chat_state_t new_state, void *user_data);
+static void demo_tts_result_callback(const tts_result_t *result, void *user_data);
+static void demo_tts_error_callback(int error_code, const char *error_msg, void *user_data);
+static void demo_tts_state_callback(tts_state_t old_state, tts_state_t new_state, void *user_data);
+
+/* ================================ 内部函数声明 ================================ */
+
+static ai_error_t demo_init_system(void);
+static ai_error_t demo_destroy_system(void);
+static ai_error_t demo_setup_connections(void);
+static ai_error_t demo_test_asr_service(void);
+static ai_error_t demo_test_chat_service(void);
+static ai_error_t demo_test_tts_service(void);
+static void demo_print_system_status(void);
+static void demo_print_statistics(void);
+static uint32_t demo_get_timestamp(void);
+
+#ifndef __TEST_MODE__
+static bool demo_build_service_urls(void);
+#endif
+
+/* ================================ 主要演示函数 ================================ */
+
+/**
+ * @brief AI服务演示主函数
+ * @return ai_error_t 错误码
+ */
+ai_error_t ai_demo_run(void)
+{
+ DEMO_LOGI("=== AI Service Demo Started ===");
+
+ g_demo_stats.demo_start_time = demo_get_timestamp();
+
+ /* 1. 初始化系统 */
+ ai_error_t ret = demo_init_system();
+ if (ret != AI_OK) {
+ DEMO_LOGE("Failed to initialize demo system: %d", ret);
+ return ret;
+ }
+
+ /* 2. 建立连接 */
+ ret = demo_setup_connections();
+ if (ret != AI_OK) {
+ DEMO_LOGE("Failed to setup connections: %d", ret);
+ demo_destroy_system();
+ return ret;
+ }
+
+ /* 3. 等待连接就绪 */
+ DEMO_LOGI("Waiting for services to be ready...");
+ ret = ai_connection_manager_wait_all_ready(10000); // 等待10秒
+ if (ret != AI_OK) {
+ DEMO_LOGW("Not all services ready, continuing with available services");
+ }
+
+ /* 4. 打印系统状态 */
+ demo_print_system_status();
+
+ g_demo_running = true;
+
+ /* 5. 依次测试各个服务 */
+ DEMO_LOGI("=== Testing ASR Service ===");
+ demo_test_asr_service();
+
+ DEMO_LOGI("=== Testing Chat Service ===");
+ demo_test_chat_service();
+
+ DEMO_LOGI("=== Testing TTS Service ===");
+ demo_test_tts_service();
+
+ /* 6. 等待一段时间让异步操作完成 */
+#ifndef __TEST_MODE__
+ osDelay(5000); // 等待5秒
+#else
+ usleep(1000000); // 等待1秒（测试模式）
+#endif
+
+ /* 7. 打印最终统计 */
+ demo_print_statistics();
+
+ /* 8. 清理资源 */
+ g_demo_running = false;
+ demo_destroy_system();
+
+ DEMO_LOGI("=== AI Service Demo Completed ===");
+ return AI_OK;
+}
+
+/**
+ * @brief AT指令演示
+ * @return ai_error_t 错误码
+ */
+ai_error_t ai_demo_at_commands(void)
+{
+ DEMO_LOGI("=== AI AT Commands Demo ===");
+
+ /* 初始化AT指令系统 */
+ ai_error_t ret = ai_at_commands_init();
+ if (ret != AI_OK) {
+ DEMO_LOGE("Failed to initialize AT commands: %d", ret);
+ return ret;
+ }
+
+ /* 演示AT指令 */
+ char response[512];
+ const char* demo_commands[] = {
+ "AT+AI+VERSION",
+ "AT+AI+INIT",
+ "AT+AI+STATUS",
+ "AT+AI+CONNECT",
+ "AT+AI+CONN_STATUS",
+ "AT+AI+ASR_CONFIG=language,zh-CN",
+ "AT+AI+CHAT_CONFIG=model,qwen-plus",
+ "AT+AI+TTS_CONFIG=voice,0",
+ "AT+AI+MEM_STATUS",
+ "AT+AI+PERF_METRICS",
+ "AT+AI+TEST_ECHO=Hello AI Demo",
+ "AT+AI+DESTROY"
+ };
+
+ size_t cmd_count = sizeof(demo_commands) / sizeof(demo_commands[0]);
+
+ for (size_t i = 0; i < cmd_count; i++) {
+ DEMO_LOGI("Executing: %s", demo_commands[i]);
+
+ memset(response, 0, sizeof(response));
+ ai_at_result_t result = ai_at_process_command(demo_commands[i], response, sizeof(response));
+
+ DEMO_LOGI("Result: %s", ai_at_get_result_string(result));
+ if (strlen(response) > 0) {
+ DEMO_LOGI("Response: %s", response);
+ }
+
+#ifndef __TEST_MODE__
+ osDelay(1000); // 等待1秒
+#else
+ usleep(100000); // 等待100ms（测试模式）
+#endif
+ }
+
+ /* 销毁AT指令系统 */
+ ai_at_commands_destroy();
+
+ DEMO_LOGI("=== AT Commands Demo Completed ===");
+ return AI_OK;
+}
+
+/**
+ * @brief 压力测试演示
+ * @param duration_seconds 测试持续时间（秒）
+ * @return ai_error_t 错误码
+ */
+ai_error_t ai_demo_stress_test(uint32_t duration_seconds)
+{
+ DEMO_LOGI("=== AI Stress Test Demo (Duration: %u seconds) ===", duration_seconds);
+
+ /* 初始化系统 */
+ ai_error_t ret = demo_init_system();
+ if (ret != AI_OK) {
+ return ret;
+ }
+
+ ret = demo_setup_connections();
+ if (ret != AI_OK) {
+ demo_destroy_system();
+ return ret;
+ }
+
+ /* 等待连接就绪 */
+ ai_connection_manager_wait_all_ready(5000);
+
+ uint32_t start_time = demo_get_timestamp();
+ uint32_t end_time = start_time + (duration_seconds * 1000);
+ uint32_t iteration = 0;
+
+ g_demo_running = true;
+
+ while (g_demo_running && demo_get_timestamp() < end_time) {
+ iteration++;
+
+ DEMO_LOGI("Stress test iteration: %u", iteration);
+
+ /* 快速连续测试各服务 */
+ demo_test_asr_service();
+ demo_test_chat_service();
+ demo_test_tts_service();
+
+ /* 内存状态检查 */
+ if (iteration % 10 == 0) {
+ uint16_t leaks = ai_memory_pool_check_leaks();
+ if (leaks > 0) {
+ DEMO_LOGW("Memory leaks detected: %d", leaks);
+ }
+
+ const ai_memory_stats_t *stats = ai_memory_pool_get_global_stats();
+ if (stats != NULL) {
+ DEMO_LOGI("Memory usage: %u%% fragmentation", stats->fragmentation);
+ }
+ }
+
+#ifndef __TEST_MODE__
+ osDelay(100); // 100ms间隔
+#else
+ usleep(10000); // 10ms间隔（测试模式）
+#endif
+ }
+
+ g_demo_running = false;
+
+ DEMO_LOGI("Stress test completed: %u iterations", iteration);
+ demo_print_statistics();
+ demo_destroy_system();
+
+ return AI_OK;
+}
+
+/* ================================ 内部函数实现 ================================ */
+
+static ai_error_t demo_init_system(void)
+{
+ if (g_demo_initialized) {
+ DEMO_LOGW("Demo system already initialized");
+ return AI_OK;
+ }
+
+ DEMO_LOGI("Initializing AI demo system...");
+
+ /* 1. 初始化内存池 */
+ ai_memory_pool_config_t mem_config;
+ ai_memory_pool_create_default_config(&mem_config);
+
+ ai_error_t ret = ai_memory_pool_init(&mem_config);
+ if (ret != AI_OK) {
+ DEMO_LOGE("Failed to initialize memory pool: %d", ret);
+ return ret;
+ }
+
+ /* 2. 初始化AI服务 */
+ ret = ai_services_init(&g_demo_services);
+ if (ret != AI_OK) {
+ DEMO_LOGE("Failed to initialize AI services: %d", ret);
+ ai_memory_pool_destroy();
+ return ret;
+ }
+
+ /* 3. 设置服务回调 */
+ ai_asr_set_callbacks(&g_demo_services,
+ demo_asr_result_callback,
+ demo_asr_error_callback,
+ demo_asr_state_callback,
+ NULL);
+
+ ai_chat_set_callbacks(&g_demo_services,
+ demo_chat_response_callback,
+ demo_chat_error_callback,
+ demo_chat_state_callback,
+ NULL);
+
+ ai_tts_set_callbacks(&g_demo_services,
+ demo_tts_result_callback,
+ demo_tts_error_callback,
+ demo_tts_state_callback,
+ NULL);
+
+ /* 4. 配置服务参数 */
+ asr_config_t asr_config;
+ ai_asr_create_default_config(&asr_config);
+ ai_asr_configure(&g_demo_services, &asr_config);
+
+ chat_config_t chat_config;
+ ai_chat_create_default_config(&chat_config);
+ ai_chat_configure(&g_demo_services, &chat_config);
+
+ tts_config_t tts_config;
+ ai_tts_create_default_config(&tts_config);
+ ai_tts_configure(&g_demo_services, &tts_config);
+
+ g_demo_initialized = true;
+
+ DEMO_LOGI("AI demo system initialized successfully");
+ return AI_OK;
+}
+
+static ai_error_t demo_destroy_system(void)
+{
+ if (!g_demo_initialized) {
+ return AI_OK;
+ }
+
+ DEMO_LOGI("Destroying AI demo system...");
+
+ /* 停止所有连接 */
+ ai_connection_manager_stop_all();
+
+ /* 销毁连接管理器 */
+ ai_connection_manager_destroy();
+
+ /* 销毁AI服务 */
+ ai_services_destroy(&g_demo_services);
+
+ /* 销毁内存池 */
+ ai_memory_pool_destroy();
+
+ g_demo_initialized = false;
+
+ DEMO_LOGI("AI demo system destroyed");
+ return AI_OK;
+}
+
+static ai_error_t demo_setup_connections(void)
+{
+ DEMO_LOGI("Setting up AI service connections...");
+
+ /* 创建连接管理器配置 */
+ ai_connection_manager_config_t conn_config;
+ ai_connection_manager_create_default_config(&conn_config);
+
+ /* 设置服务URL */
+#ifndef __TEST_MODE__
+ if (!demo_build_service_urls()) {
+ DEMO_LOGW("Failed to build service URLs, using defaults");
+ }
+#endif
+
+ strncpy(conn_config.connection_config.asr_url, DEMO_ASR_URL, AI_MAX_URL_LENGTH - 1);
+ strncpy(conn_config.connection_config.chat_url, DEMO_CHAT_URL, AI_MAX_URL_LENGTH - 1);
+ strncpy(conn_config.connection_config.tts_url, DEMO_TTS_URL, AI_MAX_URL_LENGTH - 1);
+
+ /* 设置回调 */
+ conn_config.event_callback = demo_connection_event_callback;
+
+ /* 初始化连接管理器 */
+ ai_error_t ret = ai_connection_manager_init(&conn_config);
+ if (ret != AI_OK) {
+ DEMO_LOGE("Failed to initialize connection manager: %d", ret);
+ return ret;
+ }
+
+ /* 启动连接 */
+ ret = ai_connection_manager_start_all();
+ if (ret != AI_OK) {
+ DEMO_LOGE("Failed to start connections: %d", ret);
+ return ret;
+ }
+
+ DEMO_LOGI("AI service connections setup completed");
+ return AI_OK;
+}
+
+static ai_error_t demo_test_asr_service(void)
+{
+ DEMO_LOGI("Testing ASR service...");
+
+ /* 检查ASR连接状态 */
+ ai_connection_state_t state = ai_connection_manager_get_connection_state(AI_SERVICE_ASR);
+ if (state != AI_CONN_STATE_CONNECTED) {
+ DEMO_LOGW("ASR service not connected, skipping test");
+ return AI_ERROR_SERVICE_UNAVAILABLE;
+ }
+
+ /* 开始ASR识别 */
+ ai_error_t ret = ai_asr_start(&g_demo_services, NULL);
+ if (ret != AI_OK) {
+ DEMO_LOGE("Failed to start ASR: %d", ret);
+ return ret;
+ }
+
+ /* 发送模拟音频数据 */
+ uint8_t *audio_data = malloc(DEMO_AUDIO_DATA_SIZE);
+ if (audio_data == NULL) {
+ DEMO_LOGE("Failed to allocate audio buffer");
+ ai_asr_stop(&g_demo_services);
+ return AI_ERROR_MEMORY_ALLOC;
+ }
+
+ /* 生成模拟音频数据 */
+ for (int i = 0; i < DEMO_AUDIO_DATA_SIZE; i++) {
+ audio_data[i] = (uint8_t)(i % 256);
+ }
+
+ ret = ai_asr_send_audio(&g_demo_services, audio_data, DEMO_AUDIO_DATA_SIZE);
+ free(audio_data);
+
+ if (ret != AI_OK) {
+ DEMO_LOGE("Failed to send audio data: %d", ret);
+ ai_asr_stop(&g_demo_services);
+ return ret;
+ }
+
+ /* 等待一段时间后停止 */
+#ifndef __TEST_MODE__
+ osDelay(2000); // 等待2秒
+#else
+ usleep(200000); // 等待200ms（测试模式）
+#endif
+
+ ai_asr_stop(&g_demo_services);
+
+ DEMO_LOGI("ASR service test completed");
+ return AI_OK;
+}
+
+static ai_error_t demo_test_chat_service(void)
+{
+ DEMO_LOGI("Testing Chat service...");
+
+ /* 检查Chat连接状态 */
+ ai_connection_state_t state = ai_connection_manager_get_connection_state(AI_SERVICE_CHAT);
+ if (state != AI_CONN_STATE_CONNECTED) {
+ DEMO_LOGW("Chat service not connected, skipping test");
+ return AI_ERROR_SERVICE_UNAVAILABLE;
+ }
+
+ /* 发送聊天消息 */
+ ai_error_t ret = ai_chat_send_message(&g_demo_services, DEMO_CHAT_MESSAGE, NULL);
+ if (ret != AI_OK) {
+ DEMO_LOGE("Failed to send chat message: %d", ret);
+ return ret;
+ }
+
+ DEMO_LOGI("Chat service test completed");
+ return AI_OK;
+}
+
+static ai_error_t demo_test_tts_service(void)
+{
+ DEMO_LOGI("Testing TTS service...");
+
+ /* 检查TTS连接状态 */
+ ai_connection_state_t state = ai_connection_manager_get_connection_state(AI_SERVICE_TTS);
+ if (state != AI_CONN_STATE_CONNECTED) {
+ DEMO_LOGW("TTS service not connected, skipping test");
+ return AI_ERROR_SERVICE_UNAVAILABLE;
+ }
+
+ /* 开始语音合成 */
+ ai_error_t ret = ai_tts_synthesize(&g_demo_services, DEMO_TTS_TEXT, NULL);
+ if (ret != AI_OK) {
+ DEMO_LOGE("Failed to start TTS synthesis: %d", ret);
+ return ret;
+ }
+
+ DEMO_LOGI("TTS service test completed");
+ return AI_OK;
+}
+
+static void demo_print_system_status(void)
+{
+ DEMO_LOGI("=== System Status ===");
+
+ /* 全局状态 */
+ ai_global_state_t global_state = ai_connection_manager_get_state();
+ DEMO_LOGI("Global State: %s", ai_connection_manager_get_state_name(global_state));
+
+ /* 连接状态 */
+ ai_connection_matrix_t matrix = ai_connection_manager_get_matrix();
+ DEMO_LOGI("Connection Status:");
+ DEMO_LOGI(" ASR: %s", matrix.asr_connected ? "Connected" : "Disconnected");
+ DEMO_LOGI(" Chat: %s", matrix.chat_connected ? "Connected" : "Disconnected");
+ DEMO_LOGI(" TTS: %s", matrix.tts_connected ? "Connected" : "Disconnected");
+
+ /* 服务状态 */
+ DEMO_LOGI("Service Status:");
+ DEMO_LOGI(" ASR: %s", ai_services_get_state_string(AI_SERVICE_ASR, &g_demo_services));
+ DEMO_LOGI(" Chat: %s", ai_services_get_state_string(AI_SERVICE_CHAT, &g_demo_services));
+ DEMO_LOGI(" TTS: %s", ai_services_get_state_string(AI_SERVICE_TTS, &g_demo_services));
+
+ /* 内存状态 */
+ const ai_memory_stats_t *mem_stats = ai_memory_pool_get_global_stats();
+ if (mem_stats != NULL) {
+ DEMO_LOGI("Memory Status:");
+ DEMO_LOGI(" Total: %u KB, Used: %u KB, Free: %u KB",
+ mem_stats->total_size / 1024,
+ mem_stats->used_size / 1024,
+ mem_stats->free_size / 1024);
+ DEMO_LOGI(" Fragmentation: %u%%", mem_stats->fragmentation);
+ }
+
+ DEMO_LOGI("====================");
+}
+
+static void demo_print_statistics(void)
+{
+ DEMO_LOGI("=== Demo Statistics ===");
+
+ uint32_t elapsed_time = demo_get_timestamp() - g_demo_stats.demo_start_time;
+
+ DEMO_LOGI("Runtime: %u ms", elapsed_time);
+ DEMO_LOGI("ASR Results Received: %u", g_demo_stats.asr_results_received);
+ DEMO_LOGI("Chat Responses Received: %u", g_demo_stats.chat_responses_received);
+ DEMO_LOGI("TTS Results Received: %u", g_demo_stats.tts_results_received);
+ DEMO_LOGI("Total Errors: %u", g_demo_stats.total_errors);
+
+ /* 连接性能指标 */
+ const ai_connect_metrics_t *conn_metrics = ai_connection_manager_get_metrics();
+ if (conn_metrics != NULL) {
+ DEMO_LOGI("Connection Metrics:");
+ DEMO_LOGI(" Total Connect Time: %u ms", conn_metrics->total_connect_time_ms);
+ DEMO_LOGI(" Success Rate: %u%%", conn_metrics->success_rate);
+ DEMO_LOGI(" Bytes Sent: %u", conn_metrics->total_bytes_sent);
+ DEMO_LOGI(" Bytes Received: %u", conn_metrics->total_bytes_received);
+ }
+
+ /* 内存泄漏检查 */
+ uint16_t leaks = ai_memory_pool_check_leaks();
+ if (leaks > 0) {
+ DEMO_LOGW("Memory leaks detected: %d", leaks);
+ } else {
+ DEMO_LOGI("No memory leaks detected");
+ }
+
+ DEMO_LOGI("======================");
+}
+
+static uint32_t demo_get_timestamp(void)
+{
+#ifndef __TEST_MODE__
+ return (uint32_t)(osKernelGetTickCount() * 1000 / osKernelGetTickFreq());
+#else
+ return (uint32_t)(clock() / (CLOCKS_PER_SEC / 1000));
+#endif
+}
+
+#ifndef __TEST_MODE__
+static bool demo_build_service_urls(void)
+{
+ char token[64] = {0};
+
+ /* 获取设备令牌 */
+ if (!read_dev_token(token)) {
+ DEMO_LOGW("Failed to read device token, using default URLs");
+ return false;
+ }
+
+ /* 这里可以根据token构建完整的服务URL */
+ DEMO_LOGI("Device token: %s", token);
+ return true;
+}
+#endif
+
+/* ================================ 回调函数实现 ================================ */
+
+static void demo_connection_event_callback(const ai_event_t *event, void *user_data)
+{
+ if (event == NULL) {
+ return;
+ }
+
+ const char *service_name = ai_connection_manager_get_service_name(event->service);
+
+ switch (event->type) {
+ case AI_EVENT_CONNECTION_ESTABLISHED:
+ DEMO_LOGI("Connection established: %s", service_name);
+ break;
+ case AI_EVENT_CONNECTION_LOST:
+ DEMO_LOGW("Connection lost: %s", service_name);
+ break;
+ case AI_EVENT_ERROR_OCCURRED:
+ DEMO_LOGE("Connection error: %s, code=%d", service_name, event->payload.error.error_code);
+ g_demo_stats.total_errors++;
+ break;
+ case AI_EVENT_STATE_CHANGED:
+ DEMO_LOGI("State changed: %s -> %s",
+ ai_connection_manager_get_state_name(event->payload.state_change.old_state),
+ ai_connection_manager_get_state_name(event->payload.state_change.new_state));
+ break;
+ default:
+ break;
+ }
+}
+
+static void demo_asr_result_callback(const asr_result_t *result, void *user_data)
+{
+ if (result == NULL) {
+ return;
+ }
+
+ g_demo_stats.asr_results_received++;
+
+ DEMO_LOGI("ASR Result [%s]: %s (confidence: %.2f, final: %s)",
+ result->session_id, result->text, result->confidence,
+ result->is_final ? "true" : "false");
+}
+
+static void demo_asr_error_callback(int error_code, const char *error_msg, void *user_data)
+{
+ g_demo_stats.total_errors++;
+ DEMO_LOGE("ASR Error: %d - %s", error_code, error_msg ? error_msg : "Unknown");
+}
+
+static void demo_asr_state_callback(asr_state_t old_state, asr_state_t new_state, void *user_data)
+{
+ DEMO_LOGI("ASR State: %d -> %d", old_state, new_state);
+}
+
+static void demo_chat_response_callback(const chat_message_t *message, void *user_data)
+{
+ if (message == NULL) {
+ return;
+ }
+
+ g_demo_stats.chat_responses_received++;
+
+ DEMO_LOGI("Chat Response [%s]: %.100s... (final: %s)",
+ message->session_id, message->content,
+ message->is_final ? "true" : "false");
+}
+
+static void demo_chat_error_callback(int error_code, const char *error_msg, void *user_data)
+{
+ g_demo_stats.total_errors++;
+ DEMO_LOGE("Chat Error: %d - %s", error_code, error_msg ? error_msg : "Unknown");
+}
+
+static void demo_chat_state_callback(chat_state_t old_state, chat_state_t new_state, void *user_data)
+{
+ DEMO_LOGI("Chat State: %d -> %d", old_state, new_state);
+}
+
+static void demo_tts_result_callback(const tts_result_t *result, void *user_data)
+{
+ if (result == NULL) {
+ return;
+ }
+
+ g_demo_stats.tts_results_received++;
+
+ DEMO_LOGI("TTS Result [%s]: %u bytes audio (final: %s)",
+ result->session_id, result->audio_size,
+ result->is_final ? "true" : "false");
+}
+
+static void demo_tts_error_callback(int error_code, const char *error_msg, void *user_data)
+{
+ g_demo_stats.total_errors++;
+ DEMO_LOGE("TTS Error: %d - %s", error_code, error_msg ? error_msg : "Unknown");
+}
+
+static void demo_tts_state_callback(tts_state_t old_state, tts_state_t new_state, void *user_data)
+{
+ DEMO_LOGI("TTS State: %d -> %d", old_state, new_state);
+}
+
+/* ================================ 测试模式主函数 ================================ */
+
+#ifdef __TEST_MODE__
+int main(int argc, char *argv[])
+{
+ printf("AI Service Demo - Test Mode\n");
+ printf("==========================\n");
+
+ /* 运行基本演示 */
+ ai_error_t ret = ai_demo_run();
+ if (ret != AI_OK) {
+ printf("Demo failed with error: %d\n", ret);
+ return -1;
+ }
+
+ printf("\n");
+
+ /* 运行AT指令演示 */
+ ret = ai_demo_at_commands();
+ if (ret != AI_OK) {
+ printf("AT commands demo failed with error: %d\n", ret);
+ return -1;
+ }
+
+ printf("\n");
+
+ /* 运行短时间压力测试 */
+ ret = ai_demo_stress_test(3); // 3秒压力测试
+ if (ret != AI_OK) {
+ printf("Stress test failed with error: %d\n", ret);
+ return -1;
+ }
+
+ printf("\nAll demos completed successfully!\n");
+ return 0;
+}
+#endif
\ No newline at end of file
+++ /dev/null
-/*
- * Copyright (c) CompanyNameMagicTag. 2023-2023. All rights reserved.
- * Description: AI Service Usage Example - AI全家桶使用示例
- * Author: AI Development Team
- * Create: 2024-12-28
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "ai_service_manager.h"
-#include "../../../../application/wearable/ohos_deps/wearable_log.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* ==================== 示例配置 ==================== */
-
-#define EXAMPLE_LOG_TAG "AI_EXAMPLE"
-
-// 服务器配置
-#define ASR_SERVER_URL "ws://amp.raisound.com/asr/ws"
-#define CHAT_SERVER_URL "ws://chat.example.com/chat"
-#define TTS_SERVER_URL "ws://tts.example.com/tts"
-
-/* ==================== 全局变量 ==================== */
-
-static ai_manager_context_t g_ai_manager;
-static bool g_conversation_active = false;
-static bool g_listening = false;
-
-/* ==================== 事件回调函数 ==================== */
-
-/**
- * @brief AI事件回调函数
- */
-void on_ai_event(void *user_data, const ai_event_data_t *event)
-{
- if (event == NULL) {
- return;
- }
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Event: %s, Session: %s",
- EXAMPLE_LOG_TAG,
- ai_manager_event_type_to_string(event->type),
- event->session_id);
-
- switch (event->type) {
- case AI_EVENT_CONVERSATION_START:
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] 对话开始", EXAMPLE_LOG_TAG);
- g_conversation_active = true;
- break;
-
- case AI_EVENT_SPEECH_START:
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] 开始语音输入", EXAMPLE_LOG_TAG);
- g_listening = true;
- break;
-
- case AI_EVENT_SPEECH_PARTIAL:
- if (event->text != NULL) {
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] 识别中: %s (置信度: %.2f)",
- EXAMPLE_LOG_TAG, event->text, event->confidence);
- }
- break;
-
- case AI_EVENT_SPEECH_END:
- if (event->text != NULL) {
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] 识别完成: %s (置信度: %.2f)",
- EXAMPLE_LOG_TAG, event->text, event->confidence);
- }
- g_listening = false;
- break;
-
- case AI_EVENT_CHAT_RESPONSE_START:
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] AI开始回复", EXAMPLE_LOG_TAG);
- break;
-
- case AI_EVENT_CHAT_RESPONSE_PARTIAL:
- if (event->text != NULL) {
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] AI回复中: %s",
- EXAMPLE_LOG_TAG, event->text);
- }
- break;
-
- case AI_EVENT_CHAT_RESPONSE_END:
- if (event->text != NULL) {
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] AI回复完成: %s",
- EXAMPLE_LOG_TAG, event->text);
- }
- break;
-
- case AI_EVENT_TTS_START:
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] 开始语音播放", EXAMPLE_LOG_TAG);
- break;
-
- case AI_EVENT_TTS_END:
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] 语音播放完成", EXAMPLE_LOG_TAG);
- break;
-
- case AI_EVENT_CONVERSATION_END:
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] 对话结束", EXAMPLE_LOG_TAG);
- g_conversation_active = false;
- g_listening = false;
- break;
-
- case AI_EVENT_ERROR:
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] 错误: %d - %s",
- EXAMPLE_LOG_TAG, event->error_code,
- event->error_message ? event->error_message : "Unknown");
- break;
-
- default:
- break;
- }
-}
-
-/* ==================== 示例函数 ==================== */
-
-/**
- * @brief 初始化AI服务示例
- */
-int ai_service_example_init(void)
-{
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] 初始化AI服务示例", EXAMPLE_LOG_TAG);
-
- // 创建默认配置
- ai_manager_config_t config;
- ai_manager_create_default_config(&config);
-
- // 设置服务器地址
- strcpy(config.asr_server_url, ASR_SERVER_URL);
- config.asr_server_port = 80;
- strcpy(config.chat_server_url, CHAT_SERVER_URL);
- config.chat_server_port = 80;
- strcpy(config.tts_server_url, TTS_SERVER_URL);
- config.tts_server_port = 80;
-
- // 设置超时和重试
- config.connect_timeout_ms = 30000;
- config.response_timeout_ms = 60000;
- config.auto_reconnect = true;
- config.max_retry_count = 3;
-
- // 初始化AI管理器
- ai_service_error_t ret = ai_manager_init(&g_ai_manager, &config);
- if (ret != AI_SERVICE_OK) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] 初始化AI管理器失败: %d", EXAMPLE_LOG_TAG, ret);
- return -1;
- }
-
- // 设置事件回调
- ai_manager_set_event_callback(&g_ai_manager, on_ai_event, NULL);
-
- // 启动AI服务
- ret = ai_manager_start(&g_ai_manager);
- if (ret != AI_SERVICE_OK) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] 启动AI服务失败: %d", EXAMPLE_LOG_TAG, ret);
- ai_manager_destroy(&g_ai_manager);
- return -1;
- }
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] AI服务初始化成功", EXAMPLE_LOG_TAG);
- return 0;
-}
-
-/**
- * @brief 销毁AI服务示例
- */
-void ai_service_example_deinit(void)
-{
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] 销毁AI服务示例", EXAMPLE_LOG_TAG);
-
- // 结束当前对话
- if (g_conversation_active) {
- ai_manager_end_conversation(&g_ai_manager);
- }
-
- // 停止AI服务
- ai_manager_stop(&g_ai_manager);
-
- // 销毁AI管理器
- ai_manager_destroy(&g_ai_manager);
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] AI服务销毁完成", EXAMPLE_LOG_TAG);
-}
-
-/**
- * @brief 开始语音对话示例
- */
-int ai_service_example_start_voice_conversation(void)
-{
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] 开始语音对话", EXAMPLE_LOG_TAG);
-
- // 检查服务状态
- if (!ai_manager_is_service_ready(&g_ai_manager, AI_SERVICE_TYPE_ALL)) {
- WEARABLE_LOGW(WEARABLE_LOG_MODULE_APP, "[%s] AI服务未就绪", EXAMPLE_LOG_TAG);
- return -1;
- }
-
- // 开始对话
- ai_service_error_t ret = ai_manager_start_conversation(&g_ai_manager, "voice_session_001");
- if (ret != AI_SERVICE_OK) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] 开始对话失败: %d", EXAMPLE_LOG_TAG, ret);
- return -1;
- }
-
- // 开始语音输入
- ret = ai_manager_start_speech_input(&g_ai_manager);
- if (ret != AI_SERVICE_OK) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] 开始语音输入失败: %d", EXAMPLE_LOG_TAG, ret);
- ai_manager_end_conversation(&g_ai_manager);
- return -1;
- }
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] 语音对话已开始，请说话...", EXAMPLE_LOG_TAG);
- return 0;
-}
-
-/**
- * @brief 停止语音输入示例
- */
-int ai_service_example_stop_voice_input(void)
-{
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] 停止语音输入", EXAMPLE_LOG_TAG);
-
- if (!g_listening) {
- WEARABLE_LOGW(WEARABLE_LOG_MODULE_APP, "[%s] 当前未在监听", EXAMPLE_LOG_TAG);
- return -1;
- }
-
- ai_service_error_t ret = ai_manager_stop_speech_input(&g_ai_manager);
- if (ret != AI_SERVICE_OK) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] 停止语音输入失败: %d", EXAMPLE_LOG_TAG, ret);
- return -1;
- }
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] 语音输入已停止", EXAMPLE_LOG_TAG);
- return 0;
-}
-
-/**
- * @brief 发送文本消息示例
- */
-int ai_service_example_send_text(const char *text)
-{
- if (text == NULL || strlen(text) == 0) {
- WEARABLE_LOGW(WEARABLE_LOG_MODULE_APP, "[%s] 文本内容为空", EXAMPLE_LOG_TAG);
- return -1;
- }
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] 发送文本消息: %s", EXAMPLE_LOG_TAG, text);
-
- // 如果没有活跃对话，先开始对话
- if (!g_conversation_active) {
- ai_service_error_t ret = ai_manager_start_conversation(&g_ai_manager, "text_session_001");
- if (ret != AI_SERVICE_OK) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] 开始对话失败: %d", EXAMPLE_LOG_TAG, ret);
- return -1;
- }
- }
-
- // 发送文本消息
- ai_service_error_t ret = ai_manager_send_text_message(&g_ai_manager, text);
- if (ret != AI_SERVICE_OK) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] 发送文本消息失败: %d", EXAMPLE_LOG_TAG, ret);
- return -1;
- }
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] 文本消息已发送", EXAMPLE_LOG_TAG);
- return 0;
-}
-
-/**
- * @brief 停止TTS播放示例
- */
-int ai_service_example_stop_tts(void)
-{
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] 停止TTS播放", EXAMPLE_LOG_TAG);
-
- ai_service_error_t ret = ai_manager_stop_tts_playback(&g_ai_manager);
- if (ret != AI_SERVICE_OK) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] 停止TTS播放失败: %d", EXAMPLE_LOG_TAG, ret);
- return -1;
- }
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] TTS播放已停止", EXAMPLE_LOG_TAG);
- return 0;
-}
-
-/**
- * @brief 结束对话示例
- */
-int ai_service_example_end_conversation(void)
-{
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] 结束对话", EXAMPLE_LOG_TAG);
-
- if (!g_conversation_active) {
- WEARABLE_LOGW(WEARABLE_LOG_MODULE_APP, "[%s] 当前没有活跃对话", EXAMPLE_LOG_TAG);
- return -1;
- }
-
- ai_service_error_t ret = ai_manager_end_conversation(&g_ai_manager);
- if (ret != AI_SERVICE_OK) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] 结束对话失败: %d", EXAMPLE_LOG_TAG, ret);
- return -1;
- }
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] 对话已结束", EXAMPLE_LOG_TAG);
- return 0;
-}
-
-/**
- * @brief 获取服务状态示例
- */
-void ai_service_example_print_status(void)
-{
- ai_manager_state_t state = ai_manager_get_state(&g_ai_manager);
- const ai_manager_stats_t *stats = ai_manager_get_stats(&g_ai_manager);
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] ========== AI服务状态 ==========", EXAMPLE_LOG_TAG);
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] 当前状态: %s", EXAMPLE_LOG_TAG, ai_manager_state_to_string(state));
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] 对话活跃: %s", EXAMPLE_LOG_TAG, g_conversation_active ? "是" : "否");
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] 正在监听: %s", EXAMPLE_LOG_TAG, g_listening ? "是" : "否");
-
- if (stats != NULL) {
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] 对话次数: %u", EXAMPLE_LOG_TAG, stats->conversation_count);
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] ASR识别次数: %u", EXAMPLE_LOG_TAG, stats->asr_recognition_count);
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Chat请求次数: %u", EXAMPLE_LOG_TAG, stats->chat_request_count);
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] TTS合成次数: %u", EXAMPLE_LOG_TAG, stats->tts_synthesis_count);
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] 总错误数: %u", EXAMPLE_LOG_TAG, stats->total_errors);
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] 平均响应时间: %.2f ms", EXAMPLE_LOG_TAG, stats->avg_response_time_ms);
- }
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] ASR服务就绪: %s", EXAMPLE_LOG_TAG,
- ai_manager_is_service_ready(&g_ai_manager, AI_SERVICE_TYPE_ASR) ? "是" : "否");
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Chat服务就绪: %s", EXAMPLE_LOG_TAG,
- ai_manager_is_service_ready(&g_ai_manager, AI_SERVICE_TYPE_CHAT) ? "是" : "否");
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] TTS服务就绪: %s", EXAMPLE_LOG_TAG,
- ai_manager_is_service_ready(&g_ai_manager, AI_SERVICE_TYPE_TTS) ? "是" : "否");
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] ================================", EXAMPLE_LOG_TAG);
-}
-
-/**
- * @brief 完整对话流程示例
- */
-int ai_service_example_full_conversation_demo(void)
-{
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] ========== 完整对话流程演示 ==========", EXAMPLE_LOG_TAG);
-
- // 1. 开始语音对话
- if (ai_service_example_start_voice_conversation() != 0) {
- return -1;
- }
-
- // 模拟等待用户说话
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] 模拟用户说话 3 秒...", EXAMPLE_LOG_TAG);
- osDelay(3000);
-
- // 2. 停止语音输入
- if (ai_service_example_stop_voice_input() != 0) {
- return -1;
- }
-
- // 模拟等待AI回复
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] 等待AI回复...", EXAMPLE_LOG_TAG);
- osDelay(2000);
-
- // 3. 发送文本消息
- if (ai_service_example_send_text("请介绍一下你自己") != 0) {
- return -1;
- }
-
- // 模拟等待AI回复
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] 等待AI文本回复...", EXAMPLE_LOG_TAG);
- osDelay(3000);
-
- // 4. 再次语音输入
- if (ai_manager_start_speech_input(&g_ai_manager) == AI_SERVICE_OK) {
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] 再次开始语音输入...", EXAMPLE_LOG_TAG);
- osDelay(2000);
- ai_manager_stop_speech_input(&g_ai_manager);
- }
-
- // 5. 打印状态
- ai_service_example_print_status();
-
- // 6. 结束对话
- if (ai_service_example_end_conversation() != 0) {
- return -1;
- }
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] ========== 对话流程演示完成 ==========", EXAMPLE_LOG_TAG);
- return 0;
-}
-
-/**
- * @brief 主示例函数
- */
-int ai_service_example_main(void)
-{
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] ========== AI服务使用示例 ==========", EXAMPLE_LOG_TAG);
-
- // 初始化AI服务
- if (ai_service_example_init() != 0) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] AI服务初始化失败", EXAMPLE_LOG_TAG);
- return -1;
- }
-
- // 等待服务就绪
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] 等待服务就绪...", EXAMPLE_LOG_TAG);
- int retry_count = 0;
- while (!ai_manager_is_service_ready(&g_ai_manager, AI_SERVICE_TYPE_ALL) && retry_count < 30) {
- osDelay(1000);
- retry_count++;
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] 等待服务就绪... (%d/30)", EXAMPLE_LOG_TAG, retry_count);
- }
-
- if (!ai_manager_is_service_ready(&g_ai_manager, AI_SERVICE_TYPE_ALL)) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] 服务未能就绪，退出示例", EXAMPLE_LOG_TAG);
- ai_service_example_deinit();
- return -1;
- }
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] 所有服务已就绪！", EXAMPLE_LOG_TAG);
-
- // 运行完整对话演示
- ai_service_example_full_conversation_demo();
-
- // 额外的单独功能测试
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] 测试单独文本对话...", EXAMPLE_LOG_TAG);
- ai_service_example_send_text("今天天气怎么样？");
- osDelay(3000);
-
- ai_service_example_send_text("谢谢你的回答");
- osDelay(2000);
-
- // 最终状态打印
- ai_service_example_print_status();
-
- // 清理资源
- ai_service_example_deinit();
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] ========== 示例运行完成 ==========", EXAMPLE_LOG_TAG);
- return 0;
-}
-
-#ifdef __cplusplus
-}
-#endif
\ No newline at end of file
+++ /dev/null
-/*
- * AI服务集成示例代码
- * 演示ASR、TTS、Chat三个服务的协同工作
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "asr_server.h"
-#include "tts_server.h"
-#include "chat_server.h"
-#include "../../../../../application/wearable/ohos_deps/wearable_log.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* 示例配置 */
-#define EXAMPLE_LOG_TAG "AI_EXAMPLE"
-#define ASR_SERVER_URL "ws://asr.example.com/ws"
-#define TTS_SERVER_URL "ws://tts.example.com/ws"
-#define CHAT_SERVER_URL "ws://chat.example.com/ws"
-
-/* 全局服务上下文 */
-static asr_server_context_t g_asr_context;
-static tts_server_context_t g_tts_context;
-static chat_server_context_t g_chat_context;
-
-/* 示例音频数据（模拟录音） */
-static const char g_sample_audio[] = {
- 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
- 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
- // ... 更多音频数据
-};
-
-/* 回调函数声明 */
-static void on_asr_recognition_result(void *context, const asr_recognition_result_t *result);
-static void on_asr_recognition_start(void *context, const char *session_id);
-static void on_asr_recognition_end(void *context, const char *session_id);
-static void on_asr_audio_level(void *context, float level);
-
-static void on_tts_synthesis_start(void *context, const char *session_id);
-static void on_tts_synthesis_result(void *context, const tts_synthesis_result_t *result);
-static void on_tts_synthesis_complete(void *context, const char *session_id);
-static void on_tts_playback_start(void *context);
-static void on_tts_playback_complete(void *context);
-static void on_tts_playback_error(void *context, int error_code);
-
-static void on_chat_start(void *context, const char *session_id);
-static void on_chat_response(void *context, const chat_response_t *response);
-static void on_chat_complete(void *context, const char *session_id);
-static void on_chat_streaming(void *context, const char *session_id, const char *partial_content);
-
-/* TTS接口函数 */
-static ai_service_error_t tts_send_text_interface(const char *text, const char *session_id);
-
-/* 示例函数声明 */
-static ai_service_error_t init_all_services(void);
-static ai_service_error_t start_all_services(void);
-static ai_service_error_t stop_all_services(void);
-static ai_service_error_t destroy_all_services(void);
-static void run_voice_conversation_example(void);
-static void run_text_to_speech_example(void);
-static void run_speech_recognition_example(void);
-static void print_service_stats(void);
-bool pre_AI_init(void)
-{
- if(read_dev_token(NULL)==false)
- {
- return aut_login();
- }
-}
-/* 主函数 */
-int ai_services_example_main(void)
-{
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] AI Services Example Started", EXAMPLE_LOG_TAG);
-
- if (pre_AI_init())
- {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Failed to initialize AI services", EXAMPLE_LOG_TAG);
- return -1;
- }
-
- // 初始化所有服务
- ai_service_error_t ret = init_all_services();
- if (ret != AI_SERVICE_OK) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Failed to initialize services: %d", EXAMPLE_LOG_TAG, ret);
- return -1;
- }
-
- // 启动所有服务
- ret = start_all_services();
- if (ret != AI_SERVICE_OK) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Failed to start services: %d", EXAMPLE_LOG_TAG, ret);
- destroy_all_services();
- return -1;
- }
-
- // 等待服务连接
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Waiting for services to connect...", EXAMPLE_LOG_TAG);
- osDelay(3000); // 等待3秒
-
- // 运行示例
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Running examples...", EXAMPLE_LOG_TAG);
-
- // 1. 语音识别示例
- run_speech_recognition_example();
- osDelay(2000);
-
- // 2. 文本转语音示例
- run_text_to_speech_example();
- osDelay(2000);
-
- // 3. 语音对话示例
- run_voice_conversation_example();
- osDelay(5000);
-
- // 打印统计信息
- print_service_stats();
-
- // 停止和销毁服务
- stop_all_services();
- destroy_all_services();
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] AI Services Example Completed", EXAMPLE_LOG_TAG);
-
- return 0;
-}
-
-/* 服务初始化函数 */
-static ai_service_error_t init_all_services(void)
-{
- ai_service_error_t ret;
-
- // 初始化ASR服务
- asr_audio_config_t asr_audio_config;
- asr_server_create_default_audio_config(&asr_audio_config);
-
- asr_recognition_config_t asr_recognition_config;
- asr_server_create_default_recognition_config(&asr_recognition_config);
-
- ret = asr_server_init(&g_asr_context, ASR_SERVER_URL, &asr_audio_config, &asr_recognition_config);
- if (ret != AI_SERVICE_OK) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Failed to init ASR server: %d", EXAMPLE_LOG_TAG, ret);
- return ret;
- }
-
- // 设置ASR回调
- asr_server_set_callbacks(&g_asr_context,
- on_asr_recognition_result,
- on_asr_recognition_start,
- on_asr_recognition_end,
- on_asr_audio_level);
-
- // 初始化TTS服务
- tts_audio_config_t tts_audio_config;
- tts_server_create_default_audio_config(&tts_audio_config);
-
- tts_voice_config_t tts_voice_config;
- tts_server_create_default_voice_config(&tts_voice_config);
-
- ret = tts_server_init(&g_tts_context, TTS_SERVER_URL, &tts_audio_config, &tts_voice_config);
- if (ret != AI_SERVICE_OK) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Failed to init TTS server: %d", EXAMPLE_LOG_TAG, ret);
- asr_server_destroy(&g_asr_context);
- return ret;
- }
-
- // 设置TTS回调
- tts_server_set_callbacks(&g_tts_context,
- on_tts_synthesis_start,
- on_tts_synthesis_result,
- on_tts_synthesis_complete,
- on_tts_playback_start,
- on_tts_playback_complete,
- on_tts_playback_error);
-
- // 初始化Chat服务
- chat_model_config_t chat_model_config;
- chat_server_create_default_model_config(&chat_model_config);
-
- ret = chat_server_init(&g_chat_context, CHAT_SERVER_URL, &chat_model_config);
- if (ret != AI_SERVICE_OK) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Failed to init Chat server: %d", EXAMPLE_LOG_TAG, ret);
- tts_server_destroy(&g_tts_context);
- asr_server_destroy(&g_asr_context);
- return ret;
- }
-
- // 设置Chat回调
- chat_server_set_callbacks(&g_chat_context,
- on_chat_start,
- on_chat_response,
- on_chat_complete,
- on_chat_streaming);
-
- // 设置Chat到TTS的接口
- chat_server_set_tts_interface(&g_chat_context, tts_send_text_interface);
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] All services initialized", EXAMPLE_LOG_TAG);
-
- return AI_SERVICE_OK;
-}
-
-static ai_service_error_t start_all_services(void)
-{
- ai_service_error_t ret;
-
- // 启动ASR服务
- ret = asr_server_start(&g_asr_context);
- if (ret != AI_SERVICE_OK) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Failed to start ASR server: %d", EXAMPLE_LOG_TAG, ret);
- return ret;
- }
-
- // 启动TTS服务
- ret = tts_server_start(&g_tts_context);
- if (ret != AI_SERVICE_OK) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Failed to start TTS server: %d", EXAMPLE_LOG_TAG, ret);
- asr_server_stop(&g_asr_context);
- return ret;
- }
-
- // 启动Chat服务
- ret = chat_server_start(&g_chat_context);
- if (ret != AI_SERVICE_OK) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Failed to start Chat server: %d", EXAMPLE_LOG_TAG, ret);
- tts_server_stop(&g_tts_context);
- asr_server_stop(&g_asr_context);
- return ret;
- }
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] All services started", EXAMPLE_LOG_TAG);
-
- return AI_SERVICE_OK;
-}
-
-static ai_service_error_t stop_all_services(void)
-{
- // 停止所有服务
- chat_server_stop(&g_chat_context);
- tts_server_stop(&g_tts_context);
- asr_server_stop(&g_asr_context);
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] All services stopped", EXAMPLE_LOG_TAG);
-
- return AI_SERVICE_OK;
-}
-
-static ai_service_error_t destroy_all_services(void)
-{
- // 销毁所有服务
- chat_server_destroy(&g_chat_context);
- tts_server_destroy(&g_tts_context);
- asr_server_destroy(&g_asr_context);
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] All services destroyed", EXAMPLE_LOG_TAG);
-
- return AI_SERVICE_OK;
-}
-
-/* 示例函数实现 */
-
-static void run_speech_recognition_example(void)
-{
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] === Speech Recognition Example ===", EXAMPLE_LOG_TAG);
-
- // 开始语音识别
- ai_service_error_t ret = asr_server_start_recognition(&g_asr_context, NULL);
- if (ret != AI_SERVICE_OK) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Failed to start recognition: %d", EXAMPLE_LOG_TAG, ret);
- return;
- }
-
- // 发送音频数据
- for (int i = 0; i < 5; i++) {
- ret = asr_server_send_audio(&g_asr_context, g_sample_audio, sizeof(g_sample_audio));
- if (ret != AI_SERVICE_OK) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Failed to send audio: %d", EXAMPLE_LOG_TAG, ret);
- break;
- }
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Sent audio chunk %d", EXAMPLE_LOG_TAG, i + 1);
- osDelay(500); // 500ms间隔
- }
-
- // 停止语音识别
- asr_server_stop_recognition(&g_asr_context);
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Speech recognition example completed", EXAMPLE_LOG_TAG);
-}
-
-static void run_text_to_speech_example(void)
-{
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] === Text-to-Speech Example ===", EXAMPLE_LOG_TAG);
-
- const char *text = "你好，这是一个文本转语音的示例。";
-
- // 合成语音
- ai_service_error_t ret = tts_server_synthesize_text(&g_tts_context, text, NULL);
- if (ret != AI_SERVICE_OK) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Failed to synthesize text: %d", EXAMPLE_LOG_TAG, ret);
- return;
- }
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Text synthesis started: %s", EXAMPLE_LOG_TAG, text);
-
- // 等待合成完成
- osDelay(3000);
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Text-to-speech example completed", EXAMPLE_LOG_TAG);
-}
-
-static void run_voice_conversation_example(void)
-{
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] === Voice Conversation Example ===", EXAMPLE_LOG_TAG);
-
- // 创建会话
- ai_service_error_t ret = chat_server_create_session(&g_chat_context, NULL);
- if (ret != AI_SERVICE_OK) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Failed to create chat session: %d", EXAMPLE_LOG_TAG, ret);
- return;
- }
-
- // 模拟语音对话流程：
- // 1. 开始语音识别
- ret = asr_server_start_recognition(&g_asr_context, NULL);
- if (ret != AI_SERVICE_OK) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Failed to start recognition: %d", EXAMPLE_LOG_TAG, ret);
- return;
- }
-
- // 2. 发送音频数据（模拟用户说话）
- for (int i = 0; i < 3; i++) {
- asr_server_send_audio(&g_asr_context, g_sample_audio, sizeof(g_sample_audio));
- osDelay(300);
- }
-
- // 3. 停止语音识别
- asr_server_stop_recognition(&g_asr_context);
-
- // 4. 模拟发送识别结果到Chat服务
- const char *user_message = "今天天气怎么样？";
- ret = chat_server_send_message(&g_chat_context, user_message, NULL);
- if (ret != AI_SERVICE_OK) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Failed to send chat message: %d", EXAMPLE_LOG_TAG, ret);
- return;
- }
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Voice conversation example completed", EXAMPLE_LOG_TAG);
-}
-
-static void print_service_stats(void)
-{
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] === Service Statistics ===", EXAMPLE_LOG_TAG);
-
- // ASR统计
- uint32_t asr_audio_sent, asr_results_received, asr_sessions;
- asr_server_get_stats(&g_asr_context, &asr_audio_sent, &asr_results_received, &asr_sessions);
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] ASR: Audio=%u bytes, Results=%u, Sessions=%u",
- EXAMPLE_LOG_TAG, asr_audio_sent, asr_results_received, asr_sessions);
-
- // TTS统计
- uint32_t tts_text_sent, tts_audio_received, tts_synthesis_sessions, tts_playback_sessions;
- tts_server_get_stats(&g_tts_context, &tts_text_sent, &tts_audio_received,
- &tts_synthesis_sessions, &tts_playback_sessions);
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] TTS: Text=%u chars, Audio=%u bytes, Synthesis=%u, Playback=%u",
- EXAMPLE_LOG_TAG, tts_text_sent, tts_audio_received, tts_synthesis_sessions, tts_playback_sessions);
-
- // Chat统计
- const chat_stats_t *chat_stats = chat_server_get_stats(&g_chat_context);
- if (chat_stats) {
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Chat: Requests=%u, Responses=%u, Tokens_sent=%u, Tokens_received=%u, Conversations=%u",
- EXAMPLE_LOG_TAG, chat_stats->total_requests, chat_stats->total_responses,
- chat_stats->total_tokens_sent, chat_stats->total_tokens_received, chat_stats->conversation_count);
- }
-}
-
-/* TTS接口函数实现 */
-static ai_service_error_t tts_send_text_interface(const char *text, const char *session_id)
-{
- if (!text) {
- return AI_SERVICE_ERROR_INVALID_PARAM;
- }
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Forwarding to TTS: %s", EXAMPLE_LOG_TAG, text);
-
- return tts_server_synthesize_text(&g_tts_context, text, session_id);
-}
-
-/* ASR回调函数实现 */
-static void on_asr_recognition_result(void *context, const asr_recognition_result_t *result)
-{
- if (!result) return;
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] ASR Result: '%s' (confidence: %.2f, final: %s)",
- EXAMPLE_LOG_TAG, result->text ? result->text : "",
- result->confidence, result->is_final ? "yes" : "no");
-
- // 如果是最终结果，发送到Chat服务
- if (result->is_final && result->text) {
- chat_server_send_message(&g_chat_context, result->text, result->session_id);
- }
-}
-
-static void on_asr_recognition_start(void *context, const char *session_id)
-{
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] ASR Recognition started: %s", EXAMPLE_LOG_TAG, session_id);
-}
-
-static void on_asr_recognition_end(void *context, const char *session_id)
-{
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] ASR Recognition ended: %s", EXAMPLE_LOG_TAG, session_id);
-}
-
-static void on_asr_audio_level(void *context, float level)
-{
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[%s] ASR Audio level: %.2f dB", EXAMPLE_LOG_TAG, level);
-}
-
-/* TTS回调函数实现 */
-static void on_tts_synthesis_start(void *context, const char *session_id)
-{
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] TTS Synthesis started: %s", EXAMPLE_LOG_TAG, session_id);
-}
-
-static void on_tts_synthesis_result(void *context, const tts_synthesis_result_t *result)
-{
- if (!result) return;
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] TTS Result: %zu bytes audio (seq: %u, final: %s)",
- EXAMPLE_LOG_TAG, result->audio_length, result->sequence_number,
- result->is_final ? "yes" : "no");
-}
-
-static void on_tts_synthesis_complete(void *context, const char *session_id)
-{
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] TTS Synthesis completed: %s", EXAMPLE_LOG_TAG, session_id);
-}
-
-static void on_tts_playback_start(void *context)
-{
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] TTS Playback started", EXAMPLE_LOG_TAG);
-}
-
-static void on_tts_playback_complete(void *context)
-{
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] TTS Playback completed", EXAMPLE_LOG_TAG);
-}
-
-static void on_tts_playback_error(void *context, int error_code)
-{
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] TTS Playback error: %d", EXAMPLE_LOG_TAG, error_code);
-}
-
-/* Chat回调函数实现 */
-static void on_chat_start(void *context, const char *session_id)
-{
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Chat started: %s", EXAMPLE_LOG_TAG, session_id);
-}
-
-static void on_chat_response(void *context, const chat_response_t *response)
-{
- if (!response) return;
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Chat Response: '%s' (tokens: %u, time: %ums)",
- EXAMPLE_LOG_TAG, response->content ? response->content : "",
- response->token_count, response->response_time_ms);
-}
-
-static void on_chat_complete(void *context, const char *session_id)
-{
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Chat completed: %s", EXAMPLE_LOG_TAG, session_id);
-}
-
-static void on_chat_streaming(void *context, const char *session_id, const char *partial_content)
-{
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Chat Streaming [%s]: %s",
- EXAMPLE_LOG_TAG, session_id, partial_content);
-}
-
-#ifdef __cplusplus
-}
-#endif
\ No newline at end of file
--- /dev/null
+/**
+ * @file ai_at_cmd.h
+ * @brief AI服务AT命令头文件 - LiteOS AT系统集成版
+ * @version 2.0.0
+ * @date 2024-09-02
+ *
+ * 本文件提供AI服务AT命令的接口定义
+ */
+
+#ifndef AI_AT_CMD_H
+#define AI_AT_CMD_H
+
+#include <stdint.h>
+#include <stdio.h>
+
+#ifdef __TEST_MODE__
+/* 测试模式下的模拟定义 */
+typedef uint32_t (*at_cmd_handle)(uint8_t *para, uint32_t para_len, char *str_cmd);
+typedef struct {
+ char *str_cmd;
+ at_cmd_handle cmd_handle;
+ char *str_common;
+} at_cmd_table_t;
+#else
+#include "errcode.h"
+#include "soc_osal.h"
+#include "at_cmd_api.h"
+#endif
+
+#ifdef __cplusplus
+#if __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+#endif /* __cplusplus */
+
+/**
+ * @brief 获取AI AT命令表
+ * @param cmd_count 返回命令数量指针
+ * @return AT命令表指针
+ */
+at_cmd_table_t *get_ai_cmd_table(uint32_t *cmd_count);
+
+#ifdef __cplusplus
+#if __cplusplus
+}
+#endif /* __cplusplus */
+#endif /* __cplusplus */
+
+#endif /* AI_AT_CMD_H */
\ No newline at end of file
--- /dev/null
+/**
+ * @file ai_at_commands.h
+ * @brief AI AT测试指令接口 - LiteOS-M优化版v2
+ * @version 2.0
+ * @date 2024-01-20
+ *
+ * AT指令功能：
+ * - AI服务管理和测试
+ * - 连接状态查询和控制
+ * - 内存池监控和调试
+ * - 性能统计和诊断
+ */
+
+#ifndef AI_AT_COMMANDS_H
+#define AI_AT_COMMANDS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "ai_core_types.h"
+
+#ifndef __TEST_MODE__
+#include "at_cmd_api.h"
+#endif
+
+/* ================================ AT指令常量定义 ================================ */
+
+#define AI_AT_CMD_MAX_PARAMS 8 // 最大参数数量
+#define AI_AT_CMD_MAX_PARAM_LEN 64 // 最大参数长度
+#define AI_AT_CMD_MAX_RESPONSE_LEN 512 // 最大响应长度
+
+/* ================================ AT指令结果定义 ================================ */
+
+typedef enum {
+ AI_AT_RESULT_OK = 0, // 成功
+ AI_AT_RESULT_ERROR = 1, // 错误
+ AI_AT_RESULT_INVALID_PARAM = 2, // 无效参数
+ AI_AT_RESULT_NOT_SUPPORTED = 3, // 不支持
+ AI_AT_RESULT_TIMEOUT = 4, // 超时
+ AI_AT_RESULT_BUSY = 5 // 忙碌
+} ai_at_result_t;
+
+/* ================================ AT指令参数结构 ================================ */
+
+typedef struct {
+ int param_count; // 参数数量
+ char params[AI_AT_CMD_MAX_PARAMS][AI_AT_CMD_MAX_PARAM_LEN]; // 参数数组
+} ai_at_params_t;
+
+/* AT指令处理函数类型 */
+typedef ai_at_result_t (*ai_at_cmd_handler_t)(const ai_at_params_t *params, char *response, size_t response_size);
+
+/* AT指令表项结构 */
+typedef struct {
+ const char *cmd_name; // 指令名称
+ ai_at_cmd_handler_t handler; // 处理函数
+ const char *description; // 指令描述
+ const char *usage; // 使用方法
+} ai_at_cmd_entry_t;
+
+/* ================================ AT指令处理函数声明 ================================ */
+
+/* 系统管理指令 */
+ai_at_result_t ai_at_cmd_init(const ai_at_params_t *params, char *response, size_t response_size);
+ai_at_result_t ai_at_cmd_destroy(const ai_at_params_t *params, char *response, size_t response_size);
+ai_at_result_t ai_at_cmd_status(const ai_at_params_t *params, char *response, size_t response_size);
+ai_at_result_t ai_at_cmd_version(const ai_at_params_t *params, char *response, size_t response_size);
+
+/* 连接管理指令 */
+ai_at_result_t ai_at_cmd_connect(const ai_at_params_t *params, char *response, size_t response_size);
+ai_at_result_t ai_at_cmd_disconnect(const ai_at_params_t *params, char *response, size_t response_size);
+ai_at_result_t ai_at_cmd_conn_status(const ai_at_params_t *params, char *response, size_t response_size);
+ai_at_result_t ai_at_cmd_set_url(const ai_at_params_t *params, char *response, size_t response_size);
+
+/* ASR服务指令 */
+ai_at_result_t ai_at_cmd_asr_start(const ai_at_params_t *params, char *response, size_t response_size);
+ai_at_result_t ai_at_cmd_asr_stop(const ai_at_params_t *params, char *response, size_t response_size);
+ai_at_result_t ai_at_cmd_asr_config(const ai_at_params_t *params, char *response, size_t response_size);
+ai_at_result_t ai_at_cmd_asr_send_audio(const ai_at_params_t *params, char *response, size_t response_size);
+
+/* Chat服务指令 */
+ai_at_result_t ai_at_cmd_chat_send(const ai_at_params_t *params, char *response, size_t response_size);
+ai_at_result_t ai_at_cmd_chat_config(const ai_at_params_t *params, char *response, size_t response_size);
+ai_at_result_t ai_at_cmd_chat_history(const ai_at_params_t *params, char *response, size_t response_size);
+
+/* TTS服务指令 */
+ai_at_result_t ai_at_cmd_tts_synthesize(const ai_at_params_t *params, char *response, size_t response_size);
+ai_at_result_t ai_at_cmd_tts_stop(const ai_at_params_t *params, char *response, size_t response_size);
+ai_at_result_t ai_at_cmd_tts_config(const ai_at_params_t *params, char *response, size_t response_size);
+
+/* 内存管理指令 */
+ai_at_result_t ai_at_cmd_mem_status(const ai_at_params_t *params, char *response, size_t response_size);
+ai_at_result_t ai_at_cmd_mem_stats(const ai_at_params_t *params, char *response, size_t response_size);
+ai_at_result_t ai_at_cmd_mem_defrag(const ai_at_params_t *params, char *response, size_t response_size);
+ai_at_result_t ai_at_cmd_mem_leak_check(const ai_at_params_t *params, char *response, size_t response_size);
+
+/* 性能监控指令 */
+ai_at_result_t ai_at_cmd_perf_metrics(const ai_at_params_t *params, char *response, size_t response_size);
+ai_at_result_t ai_at_cmd_perf_reset(const ai_at_params_t *params, char *response, size_t response_size);
+
+/* 调试和测试指令 */
+ai_at_result_t ai_at_cmd_debug_log(const ai_at_params_t *params, char *response, size_t response_size);
+ai_at_result_t ai_at_cmd_test_echo(const ai_at_params_t *params, char *response, size_t response_size);
+ai_at_result_t ai_at_cmd_test_stress(const ai_at_params_t *params, char *response, size_t response_size);
+
+/* 配置管理指令 */
+ai_at_result_t ai_at_cmd_config_save(const ai_at_params_t *params, char *response, size_t response_size);
+ai_at_result_t ai_at_cmd_config_load(const ai_at_params_t *params, char *response, size_t response_size);
+ai_at_result_t ai_at_cmd_config_reset(const ai_at_params_t *params, char *response, size_t response_size);
+
+/* ================================ 公共接口函数 ================================ */
+
+/**
+ * @brief 初始化AI AT指令系统
+ * @return ai_error_t 错误码
+ */
+ai_error_t ai_at_commands_init(void);
+
+/**
+ * @brief 销毁AI AT指令系统
+ * @return ai_error_t 错误码
+ */
+ai_error_t ai_at_commands_destroy(void);
+
+/**
+ * @brief 获取AI AT指令表
+ * @param cmd_count 输出命令数量
+ * @return const ai_at_cmd_entry_t* 指令表指针
+ */
+const ai_at_cmd_entry_t* ai_at_get_cmd_table(uint32_t *cmd_count);
+
+/**
+ * @brief 处理AI AT指令
+ * @param cmd_line 指令行
+ * @param response 响应缓冲区
+ * @param response_size 响应缓冲区大小
+ * @return ai_at_result_t 处理结果
+ */
+ai_at_result_t ai_at_process_command(const char *cmd_line, char *response, size_t response_size);
+
+/**
+ * @brief 解析AT指令参数
+ * @param cmd_line 指令行
+ * @param cmd_name 输出指令名称
+ * @param cmd_name_size 指令名称缓冲区大小
+ * @param params 输出参数结构
+ * @return ai_error_t 错误码
+ */
+ai_error_t ai_at_parse_command(const char *cmd_line, char *cmd_name, size_t cmd_name_size, ai_at_params_t *params);
+
+/**
+ * @brief 查找AT指令处理函数
+ * @param cmd_name 指令名称
+ * @return ai_at_cmd_handler_t 处理函数指针，未找到返回NULL
+ */
+ai_at_cmd_handler_t ai_at_find_command(const char *cmd_name);
+
+/* ================================ 辅助函数 ================================ */
+
+/**
+ * @brief 格式化AT响应
+ * @param response 响应缓冲区
+ * @param response_size 缓冲区大小
+ * @param result 结果码
+ * @param format 格式字符串
+ * @param ... 可变参数
+ * @return int 写入的字节数
+ */
+int ai_at_format_response(char *response, size_t response_size, ai_at_result_t result, const char *format, ...);
+
+/**
+ * @brief 解析整数参数
+ * @param param_str 参数字符串
+ * @param value 输出整数值
+ * @return bool true表示成功，false表示失败
+ */
+bool ai_at_parse_int(const char *param_str, int *value);
+
+/**
+ * @brief 解析浮点数参数
+ * @param param_str 参数字符串
+ * @param value 输出浮点数值
+ * @return bool true表示成功，false表示失败
+ */
+bool ai_at_parse_float(const char *param_str, float *value);
+
+/**
+ * @brief 解析布尔参数
+ * @param param_str 参数字符串
+ * @param value 输出布尔值
+ * @return bool true表示成功，false表示失败
+ */
+bool ai_at_parse_bool(const char *param_str, bool *value);
+
+/**
+ * @brief 获取结果码字符串
+ * @param result 结果码
+ * @return const char* 结果字符串
+ */
+const char* ai_at_get_result_string(ai_at_result_t result);
+
+/**
+ * @brief 打印指令帮助信息
+ * @param response 响应缓冲区
+ * @param response_size 缓冲区大小
+ * @param cmd_name 指令名称，NULL表示打印所有指令
+ * @return int 写入的字节数
+ */
+int ai_at_print_help(char *response, size_t response_size, const char *cmd_name);
+
+/* ================================ 系统集成接口 ================================ */
+
+#ifndef __TEST_MODE__
+/**
+ * @brief 注册AI AT指令到系统AT框架
+ * @return ai_error_t 错误码
+ */
+ai_error_t ai_at_register_commands(void);
+
+/**
+ * @brief 获取AT指令表（系统接口）
+ * @param cmd_count 输出命令数量
+ * @return at_cmd_table_t* AT指令表指针
+ */
+at_cmd_table_t* get_ai_cmd_table(uint32_t *cmd_count);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* AI_AT_COMMANDS_H */
\ No newline at end of file
--- /dev/null
+/**
+ * @file ai_connection_manager.h
+ * @brief AI多连接管理器 - LiteOS-M优化版v2
+ * @version 2.0
+ * @date 2024-01-20
+ *
+ * 多连接管理器功能：
+ * - 并发WebSocket连接建立
+ * - 连接池管理和故障恢复
+ * - 智能重连和负载均衡
+ * - 连接状态监控和性能优化
+ */
+
+#ifndef AI_CONNECTION_MANAGER_H
+#define AI_CONNECTION_MANAGER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "ai_core_types.h"
+
+/* ================================ 连接管理器配置 ================================ */
+
+typedef struct {
+ ai_multi_connection_config_t connection_config; // 连接配置
+ ai_audio_config_t audio_config; // 音频配置
+
+ /* 线程配置 */
+ uint8_t connection_thread_priority; // 连接线程优先级
+ uint8_t worker_thread_priority; // 工作线程优先级
+
+ /* 重连配置 */
+ uint8_t max_retry_count; // 最大重试次数
+ uint16_t retry_interval_ms; // 重试间隔
+ bool auto_reconnect; // 自动重连开关
+
+ /* 性能配置 */
+ bool enable_connection_cache; // 启用连接缓存
+ bool enable_metrics; // 启用性能监控
+ uint16_t keepalive_interval_ms; // 心跳间隔
+
+ /* 回调函数 */
+ ai_event_callback_t event_callback; // 事件回调
+ void *user_data; // 用户数据
+} ai_connection_manager_config_t;
+
+/* ================================ 连接信息结构 ================================ */
+
+typedef struct {
+ ai_service_type_t service_type; // 服务类型
+ ai_connection_state_t state; // 连接状态
+ char url[AI_MAX_URL_LENGTH]; // 服务URL
+
+#ifndef __TEST_MODE__
+ WebSocketClient_t websocket; // WebSocket客户端文件描述符
+ osThreadId_t thread_id; // 连接线程ID
+#else
+ int websocket; // 测试模式WebSocket fd
+ void *thread_id; // 测试模式
+#endif
+
+ uint32_t connect_time_ms; // 连接时间
+ uint32_t last_activity_time; // 最后活动时间
+ uint16_t retry_count; // 重试次数
+
+ ai_buffer_t *send_buffer; // 发送缓冲区
+ ai_buffer_t *recv_buffer; // 接收缓冲区
+
+#ifndef __TEST_MODE__
+ osMutexId_t mutex; // 连接互斥锁
+ osSemaphoreId_t ready_semaphore; // 就绪信号量
+#else
+ void *mutex; // 测试模式
+ void *ready_semaphore; // 测试模式
+#endif
+} ai_connection_info_t;
+
+/* ================================ 连接管理器上下文 ================================ */
+
+typedef struct {
+ ai_connection_manager_config_t config; // 配置信息
+ ai_global_state_t global_state; // 全局状态
+ ai_connection_matrix_t connection_matrix; // 连接状态矩阵
+
+ ai_connection_info_t connections[AI_SERVICE_COUNT]; // 连接信息数组
+ ai_connect_metrics_t metrics; // 性能指标
+
+#ifndef __TEST_MODE__
+ osThreadId_t worker_thread_id; // 工作线程ID
+ osMutexId_t global_mutex; // 全局互斥锁
+ osMessageQueueId_t event_queue; // 事件队列
+ osTimerId_t heartbeat_timer; // 心跳定时器
+#else
+ void *worker_thread_id; // 测试模式
+ void *global_mutex; // 测试模式
+ void *event_queue; // 测试模式
+ void *heartbeat_timer; // 测试模式
+#endif
+
+ bool is_initialized; // 初始化标志
+ bool is_running; // 运行标志
+ uint32_t init_timestamp; // 初始化时间戳
+} ai_connection_manager_t;
+
+/* ================================ 公共接口函数 ================================ */
+
+/**
+ * @brief 初始化连接管理器
+ * @param config 配置参数
+ * @return ai_error_t 错误码
+ */
+ai_error_t ai_connection_manager_init(const ai_connection_manager_config_t *config);
+
+/**
+ * @brief 销毁连接管理器
+ * @return ai_error_t 错误码
+ */
+ai_error_t ai_connection_manager_destroy(void);
+
+/**
+ * @brief 启动所有连接（并发模式）
+ * @return ai_error_t 错误码
+ */
+ai_error_t ai_connection_manager_start_all(void);
+
+/**
+ * @brief 停止所有连接
+ * @return ai_error_t 错误码
+ */
+ai_error_t ai_connection_manager_stop_all(void);
+
+/**
+ * @brief 发送数据到指定服务
+ * @param service_type 服务类型
+ * @param data 数据指针
+ * @param length 数据长度
+ * @return ai_error_t 错误码
+ */
+ai_error_t ai_connection_manager_send_data(ai_service_type_t service_type,
+ const char *data, size_t length);
+
+/**
+ * @brief 获取全局状态
+ * @return ai_global_state_t 全局状态
+ */
+ai_global_state_t ai_connection_manager_get_state(void);
+
+/**
+ * @brief 获取连接状态矩阵
+ * @return ai_connection_matrix_t 连接状态矩阵
+ */
+ai_connection_matrix_t ai_connection_manager_get_matrix(void);
+
+/**
+ * @brief 获取指定服务的连接状态
+ * @param service_type 服务类型
+ * @return ai_connection_state_t 连接状态
+ */
+ai_connection_state_t ai_connection_manager_get_connection_state(ai_service_type_t service_type);
+
+/**
+ * @brief 获取性能指标
+ * @return const ai_connect_metrics_t* 性能指标指针
+ */
+const ai_connect_metrics_t* ai_connection_manager_get_metrics(void);
+
+/**
+ * @brief 手动重连指定服务
+ * @param service_type 服务类型
+ * @return ai_error_t 错误码
+ */
+ai_error_t ai_connection_manager_reconnect(ai_service_type_t service_type);
+
+/**
+ * @brief 等待服务就绪
+ * @param service_type 服务类型
+ * @param timeout_ms 超时时间（毫秒）
+ * @return ai_error_t 错误码
+ */
+ai_error_t ai_connection_manager_wait_ready(ai_service_type_t service_type, uint32_t timeout_ms);
+
+/**
+ * @brief 等待所有服务就绪
+ * @param timeout_ms 超时时间（毫秒）
+ * @return ai_error_t 错误码
+ */
+ai_error_t ai_connection_manager_wait_all_ready(uint32_t timeout_ms);
+
+/* ================================ 配置辅助函数 ================================ */
+
+/**
+ * @brief 创建默认配置
+ * @param config 配置结构指针
+ */
+void ai_connection_manager_create_default_config(ai_connection_manager_config_t *config);
+
+/**
+ * @brief 设置服务URL
+ * @param config 配置结构指针
+ * @param service_type 服务类型
+ * @param url 服务URL
+ * @return ai_error_t 错误码
+ */
+ai_error_t ai_connection_manager_set_service_url(ai_connection_manager_config_t *config,
+ ai_service_type_t service_type,
+ const char *url);
+
+/**
+ * @brief 获取服务名称字符串
+ * @param service_type 服务类型
+ * @return const char* 服务名称
+ */
+const char* ai_connection_manager_get_service_name(ai_service_type_t service_type);
+
+/**
+ * @brief 获取状态名称字符串
+ * @param state 状态值
+ * @return const char* 状态名称
+ */
+const char* ai_connection_manager_get_state_name(ai_global_state_t state);
+
+/* ================================ 调试和监控函数 ================================ */
+
+/**
+ * @brief 打印连接状态信息
+ */
+void ai_connection_manager_print_status(void);
+
+/**
+ * @brief 打印性能统计信息
+ */
+void ai_connection_manager_print_metrics(void);
+
+/**
+ * @brief 重置性能统计
+ */
+void ai_connection_manager_reset_metrics(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* AI_CONNECTION_MANAGER_H */
\ No newline at end of file
--- /dev/null
+/**
+ * @file ai_core_types.h
+ * @brief AI服务核心类型定义 - LiteOS-M优化版v2
+ * @version 2.0
+ * @date 2024-01-20
+ *
+ * 基于多连接优化方案的核心类型定义
+ * - 保持多WebSocket连接快速响应
+ * - 优化内存和线程资源使用
+ * - 支持并发连接和智能缓冲区管理
+ */
+
+#ifndef AI_CORE_TYPES_H
+#define AI_CORE_TYPES_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stddef.h>
+
+/* 系统依赖头文件 - 条件编译 */
+#ifndef __TEST_MODE__
+#include "cmsis_os2.h"
+/* WebSocket相关头文件 */
+#ifdef SUPPORT_ZHIHUI_AI_SERVICE
+#include "net_websocket.h"
+/* 定义WebSocket客户端类型为文件描述符 */
+typedef int WebSocketClient_t;
+#else
+/* 如果没有WebSocket支持，提供基本类型定义 */
+typedef int WebSocketClient_t;
+/* 模拟WebSocket错误结构体 */
+struct WebSocketErrorResult {
+ int errorCode;
+ const char *errorMessage;
+};
+#endif
+#else
+/* 测试模式下的定义 */
+typedef int WebSocketClient_t;
+struct WebSocketErrorResult {
+ int errorCode;
+ const char *errorMessage;
+};
+#endif
+
+/* ================================ 基础常量定义 ================================ */
+
+/* 内存优化常量 - LiteOS-M适配 */
+#define AI_MAX_URL_LENGTH 128 // URL最大长度
+#define AI_MAX_SESSION_ID_LENGTH 32 // 会话ID最大长度
+#define AI_MAX_TEXT_LENGTH 512 // 文本最大长度（优化）
+#define AI_MAX_ERROR_MSG_LENGTH 64 // 错误消息最大长度
+
+/* 缓冲区大小定义 - 基于v2优化方案 */
+#define AI_AUDIO_IN_BUFFER_SIZE 2048 // 录音缓冲区: 2KB
+#define AI_AUDIO_OUT_BUFFER_SIZE 1024 // 播放缓冲区: 1KB
+#define AI_NETWORK_POOL_SIZE 3072 // 网络缓冲池: 3KB
+#define AI_CONNECTION_BUFFER_SIZE 1024 // 每连接缓冲区: 1KB
+
+/* 线程配置 - 优化版 */
+#define AI_CONNECTION_STACK_SIZE 4096 // 连接线程栈: 4KB
+#define AI_WORKER_STACK_SIZE 6144 // 工作线程栈: 6KB
+#define AI_MAX_CONNECTIONS 3 // 最大连接数: ASR+Chat+TTS
+
+/* 超时配置 */
+#define AI_CONNECT_TIMEOUT_MS 3000 // 连接超时: 3秒
+#define AI_RESPONSE_TIMEOUT_MS 10000 // 响应超时: 10秒
+#define AI_HEARTBEAT_INTERVAL_MS 30000 // 心跳间隔: 30秒
+
+/* ================================ 错误码定义 ================================ */
+
+typedef enum {
+ AI_OK = 0, // 成功
+ AI_ERROR_INVALID_PARAM = -1, // 无效参数
+ AI_ERROR_NOT_INITIALIZED = -2, // 未初始化
+ AI_ERROR_ALREADY_INITIALIZED = -3, // 已初始化
+ AI_ERROR_MEMORY_ALLOC = -4, // 内存分配失败
+ AI_ERROR_NETWORK = -5, // 网络错误
+ AI_ERROR_TIMEOUT = -6, // 超时
+ AI_ERROR_QUEUE_FULL = -7, // 队列满
+ AI_ERROR_QUEUE_EMPTY = -8, // 队列空
+ AI_ERROR_CONNECTION_FAILED = -9, // 连接失败
+ AI_ERROR_WEBSOCKET = -10, // WebSocket错误
+ AI_ERROR_JSON_PARSE = -11, // JSON解析错误
+ AI_ERROR_AUDIO = -12, // 音频错误
+ AI_ERROR_SERVICE_UNAVAILABLE = -13, // 服务不可用
+ AI_ERROR_BUFFER_OVERFLOW = -14, // 缓冲区溢出
+ AI_ERROR_STATE_INVALID = -15, // 状态无效
+ AI_ERROR_MUTEX_FAILED = -16 // 互斥锁操作失败
+} ai_error_t;
+
+/* ================================ 服务类型定义 ================================ */
+
+typedef enum {
+ AI_SERVICE_ASR = 0, // 语音识别服务
+ AI_SERVICE_CHAT = 1, // 对话服务
+ AI_SERVICE_TTS = 2, // 语音合成服务
+ AI_SERVICE_COUNT = 3 // 服务总数
+} ai_service_type_t;
+
+/* ================================ 连接状态定义 ================================ */
+
+typedef enum {
+ AI_CONN_STATE_DISCONNECTED = 0, // 断开连接
+ AI_CONN_STATE_CONNECTING = 1, // 连接中
+ AI_CONN_STATE_CONNECTED = 2, // 已连接
+ AI_CONN_STATE_ERROR = 3 // 连接错误
+} ai_connection_state_t;
+
+/* 连接状态矩阵 */
+typedef struct {
+ uint8_t asr_connected : 1; // ASR连接状态
+ uint8_t chat_connected : 1; // Chat连接状态
+ uint8_t tts_connected : 1; // TTS连接状态
+ uint8_t reserved : 5; // 保留位
+} ai_connection_matrix_t;
+
+/* ================================ 全局状态定义 ================================ */
+
+typedef enum {
+ AI_STATE_UNINITIALIZED = 0, // 未初始化
+ AI_STATE_INITIALIZING = 1, // 初始化中
+ AI_STATE_CONNECTING = 2, // 连接中
+ AI_STATE_READY = 3, // 全部就绪
+ AI_STATE_PARTIAL = 4, // 部分可用
+ AI_STATE_DEGRADED = 5, // 降级模式
+ AI_STATE_ERROR = 6 // 错误状态
+} ai_global_state_t;
+
+/* ================================ 音频配置定义 ================================ */
+
+typedef enum {
+ AI_AUDIO_FORMAT_PCM = 0, // PCM格式
+ AI_AUDIO_FORMAT_OPUS = 1, // OPUS格式（可选）
+ AI_AUDIO_FORMAT_MP3 = 2 // MP3格式（可选）
+} ai_audio_format_t;
+
+typedef struct {
+ uint32_t sample_rate; // 采样率 (16000)
+ uint8_t channels; // 声道数 (1)
+ uint8_t bits_per_sample; // 位深度 (16)
+ ai_audio_format_t format; // 音频格式
+} ai_audio_config_t;
+
+/* ================================ 缓冲区管理定义 ================================ */
+
+typedef struct {
+ uint8_t *buffer; // 缓冲区指针
+ uint16_t size; // 缓冲区大小
+ uint16_t used; // 已使用大小
+ uint8_t service_id; // 服务ID
+ bool is_allocated; // 是否已分配
+} ai_buffer_t;
+
+/* 内存池统计 */
+typedef struct {
+ uint32_t total_size; // 总大小
+ uint32_t used_size; // 已使用大小
+ uint32_t free_size; // 空闲大小
+ uint16_t alloc_count; // 分配次数
+ uint16_t free_count; // 释放次数
+ uint8_t fragmentation; // 碎片率(%)
+} ai_memory_stats_t;
+
+/* ================================ 连接配置定义 ================================ */
+
+typedef enum {
+ AI_CONNECT_STRATEGY_CONCURRENT = 0, // 并发连接（默认）
+ AI_CONNECT_STRATEGY_PRIORITY = 1, // 按优先级连接
+ AI_CONNECT_STRATEGY_ON_DEMAND = 2 // 按需连接
+} ai_connect_strategy_t;
+
+typedef struct {
+ char asr_url[AI_MAX_URL_LENGTH]; // ASR服务URL
+ char chat_url[AI_MAX_URL_LENGTH]; // Chat服务URL
+ char tts_url[AI_MAX_URL_LENGTH]; // TTS服务URL
+ uint16_t connect_timeout_ms; // 连接超时
+ uint8_t concurrent_connect; // 并发建连开关
+ uint8_t backup_connections; // 备用连接数
+ ai_connect_strategy_t strategy; // 连接策略
+} ai_multi_connection_config_t;
+
+/* ================================ 性能监控定义 ================================ */
+
+typedef struct {
+ uint32_t connect_time_ms[AI_SERVICE_COUNT]; // 各服务连接时间
+ uint32_t total_connect_time_ms; // 总连接时间
+ uint16_t retry_count[AI_SERVICE_COUNT]; // 重试次数
+ uint8_t success_rate; // 连接成功率
+ uint32_t last_connect_timestamp; // 最后连接时间
+ uint32_t total_bytes_sent; // 总发送字节数
+ uint32_t total_bytes_received; // 总接收字节数
+} ai_connect_metrics_t;
+
+/* ================================ 事件定义 ================================ */
+
+typedef enum {
+ AI_EVENT_CONNECTION_ESTABLISHED = 0, // 连接建立
+ AI_EVENT_CONNECTION_LOST = 1, // 连接丢失
+ AI_EVENT_DATA_RECEIVED = 2, // 数据接收
+ AI_EVENT_ERROR_OCCURRED = 3, // 错误发生
+ AI_EVENT_STATE_CHANGED = 4, // 状态变更
+ AI_EVENT_AUDIO_START = 5, // 音频开始
+ AI_EVENT_AUDIO_END = 6, // 音频结束
+ AI_EVENT_RECOGNITION_RESULT = 7, // 识别结果
+ AI_EVENT_CHAT_RESPONSE = 8, // 对话响应
+ AI_EVENT_TTS_RESULT = 9 // 合成结果
+} ai_event_type_t;
+
+typedef struct {
+ ai_event_type_t type; // 事件类型
+ ai_service_type_t service; // 相关服务
+ uint32_t timestamp; // 时间戳
+ char session_id[AI_MAX_SESSION_ID_LENGTH]; // 会话ID
+ union {
+ struct {
+ ai_connection_state_t state; // 连接状态
+ int error_code; // 错误码
+ } connection;
+ struct {
+ const char *data; // 数据指针
+ size_t length; // 数据长度
+ } data;
+ struct {
+ ai_global_state_t old_state; // 旧状态
+ ai_global_state_t new_state; // 新状态
+ } state_change;
+ struct {
+ int error_code; // 错误码
+ char message[AI_MAX_ERROR_MSG_LENGTH]; // 错误消息
+ } error;
+ } payload;
+} ai_event_t;
+
+/* 事件回调函数类型 */
+typedef void (*ai_event_callback_t)(const ai_event_t *event, void *user_data);
+
+/* ================================ 系统兼容性定义 ================================ */
+
+#ifdef __TEST_MODE__
+/* 测试模式下的类型定义 */
+typedef void* osThreadId_t;
+typedef void* osMutexId_t;
+typedef void* osSemaphoreId_t;
+typedef void* osMessageQueueId_t;
+typedef void* osTimerId_t;
+typedef int osStatus_t;
+typedef uint32_t osThreadAttr_t;
+
+#define osOK 0
+#define osError -1
+#define osErrorTimeout -2
+#define osErrorResource -3
+#define osErrorParameter -4
+#define osErrorNoMemory -5
+
+/* WebSocket相关类型 - 已在上面定义，这里不重复定义 */
+typedef int (*WebSocketCallback_t)(void *client, const char *data, size_t length);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* AI_CORE_TYPES_H */
\ No newline at end of file
--- /dev/null
+/**
+ * @file ai_memory_pool.h
+ * @brief AI智能内存池管理器 - LiteOS-M优化版v2
+ * @version 2.0
+ * @date 2024-01-20
+ *
+ * 智能内存池功能：
+ * - 分层缓冲区管理（音频固定 + 网络动态）
+ * - 内存池复用和碎片整理
+ * - 缓冲区边界检查和溢出保护
+ * - 内存使用统计和优化建议
+ */
+
+#ifndef AI_MEMORY_POOL_H
+#define AI_MEMORY_POOL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "ai_core_types.h"
+
+/* ================================ 内存池类型定义 ================================ */
+
+typedef enum {
+ AI_POOL_TYPE_AUDIO_IN = 0, // 音频输入缓冲池
+ AI_POOL_TYPE_AUDIO_OUT = 1, // 音频输出缓冲池
+ AI_POOL_TYPE_NETWORK = 2, // 网络缓冲池
+ AI_POOL_TYPE_CONNECTION = 3, // 连接缓冲池
+ AI_POOL_TYPE_COUNT = 4 // 缓冲池总数
+} ai_pool_type_t;
+
+typedef enum {
+ AI_BUFFER_STATE_FREE = 0, // 空闲状态
+ AI_BUFFER_STATE_ALLOCATED = 1, // 已分配
+ AI_BUFFER_STATE_IN_USE = 2, // 使用中
+ AI_BUFFER_STATE_RESERVED = 3 // 保留状态
+} ai_buffer_state_t;
+
+/* ================================ 内存块结构定义 ================================ */
+
+typedef struct ai_memory_block {
+ uint8_t *data; // 数据指针
+ uint16_t size; // 块大小
+ uint16_t used; // 已使用大小
+ ai_buffer_state_t state; // 块状态
+ ai_service_type_t owner_service; // 所属服务
+ uint32_t alloc_timestamp; // 分配时间戳
+ struct ai_memory_block *next; // 下一个块
+ struct ai_memory_block *prev; // 上一个块
+} ai_memory_block_t;
+
+/* ================================ 内存池结构定义 ================================ */
+
+typedef struct {
+ ai_pool_type_t type; // 池类型
+ uint8_t *pool_base; // 池基地址
+ uint32_t pool_size; // 池总大小
+ uint32_t block_size; // 块大小
+ uint16_t block_count; // 块数量
+ uint16_t free_count; // 空闲块数量
+
+ ai_memory_block_t *free_list; // 空闲链表
+ ai_memory_block_t *used_list; // 已用链表
+ ai_memory_block_t *blocks; // 块数组
+
+#ifndef __TEST_MODE__
+ osMutexId_t mutex; // 池互斥锁
+#else
+ void *mutex; // 测试模式
+#endif
+
+ /* 统计信息 */
+ uint32_t total_allocs; // 总分配次数
+ uint32_t total_frees; // 总释放次数
+ uint32_t peak_usage; // 峰值使用量
+ uint32_t current_usage; // 当前使用量
+ uint8_t fragmentation_level; // 碎片化程度
+} ai_memory_pool_t;
+
+/* ================================ 内存池管理器 ================================ */
+
+typedef struct {
+ ai_memory_pool_t pools[AI_POOL_TYPE_COUNT]; // 内存池数组
+ ai_memory_stats_t global_stats; // 全局统计
+
+ /* 全局配置 */
+ bool enable_boundary_check; // 边界检查开关
+ bool enable_auto_defrag; // 自动碎片整理
+ uint8_t defrag_threshold; // 碎片整理阈值(%)
+ uint16_t gc_interval_ms; // 垃圾回收间隔
+
+#ifndef __TEST_MODE__
+ osMutexId_t global_mutex; // 全局互斥锁
+ osTimerId_t gc_timer; // 垃圾回收定时器
+#else
+ void *global_mutex; // 测试模式
+ void *gc_timer; // 测试模式
+#endif
+
+ bool is_initialized; // 初始化标志
+ uint32_t init_timestamp; // 初始化时间戳
+} ai_memory_pool_manager_t;
+
+/* ================================ 配置结构定义 ================================ */
+
+typedef struct {
+ /* 各池配置 */
+ uint32_t audio_in_pool_size; // 音频输入池大小
+ uint32_t audio_out_pool_size; // 音频输出池大小
+ uint32_t network_pool_size; // 网络池大小
+ uint32_t connection_pool_size; // 连接池大小
+
+ /* 块大小配置 */
+ uint16_t audio_in_block_size; // 音频输入块大小
+ uint16_t audio_out_block_size; // 音频输出块大小
+ uint16_t network_block_size; // 网络块大小
+ uint16_t connection_block_size; // 连接块大小
+
+ /* 管理配置 */
+ bool enable_boundary_check; // 边界检查
+ bool enable_auto_defrag; // 自动碎片整理
+ uint8_t defrag_threshold; // 碎片整理阈值
+ uint16_t gc_interval_ms; // 垃圾回收间隔
+} ai_memory_pool_config_t;
+
+/* ================================ 公共接口函数 ================================ */
+
+/**
+ * @brief 初始化内存池管理器
+ * @param config 配置参数
+ * @return ai_error_t 错误码
+ */
+ai_error_t ai_memory_pool_init(const ai_memory_pool_config_t *config);
+
+/**
+ * @brief 销毁内存池管理器
+ * @return ai_error_t 错误码
+ */
+ai_error_t ai_memory_pool_destroy(void);
+
+/**
+ * @brief 分配缓冲区
+ * @param pool_type 池类型
+ * @param size 请求大小
+ * @param service_type 服务类型
+ * @return ai_buffer_t* 缓冲区指针，失败返回NULL
+ */
+ai_buffer_t* ai_memory_pool_alloc(ai_pool_type_t pool_type, uint16_t size,
+ ai_service_type_t service_type);
+
+/**
+ * @brief 释放缓冲区
+ * @param buffer 缓冲区指针
+ * @return ai_error_t 错误码
+ */
+ai_error_t ai_memory_pool_free(ai_buffer_t *buffer);
+
+/**
+ * @brief 调整缓冲区大小
+ * @param buffer 缓冲区指针
+ * @param new_size 新大小
+ * @return ai_error_t 错误码
+ */
+ai_error_t ai_memory_pool_resize(ai_buffer_t *buffer, uint16_t new_size);
+
+/**
+ * @brief 获取内存池统计信息
+ * @param pool_type 池类型
+ * @return const ai_memory_stats_t* 统计信息指针
+ */
+const ai_memory_stats_t* ai_memory_pool_get_stats(ai_pool_type_t pool_type);
+
+/**
+ * @brief 获取全局内存统计
+ * @return const ai_memory_stats_t* 全局统计指针
+ */
+const ai_memory_stats_t* ai_memory_pool_get_global_stats(void);
+
+/**
+ * @brief 手动触发碎片整理
+ * @param pool_type 池类型，AI_POOL_TYPE_COUNT表示所有池
+ * @return ai_error_t 错误码
+ */
+ai_error_t ai_memory_pool_defragment(ai_pool_type_t pool_type);
+
+/**
+ * @brief 检查缓冲区有效性
+ * @param buffer 缓冲区指针
+ * @return bool true表示有效，false表示无效
+ */
+bool ai_memory_pool_validate_buffer(const ai_buffer_t *buffer);
+
+/* ================================ 智能分配函数 ================================ */
+
+/**
+ * @brief 智能分配音频输入缓冲区
+ * @param service_type 服务类型
+ * @return ai_buffer_t* 缓冲区指针
+ */
+ai_buffer_t* ai_memory_pool_alloc_audio_in(ai_service_type_t service_type);
+
+/**
+ * @brief 智能分配音频输出缓冲区
+ * @param service_type 服务类型
+ * @return ai_buffer_t* 缓冲区指针
+ */
+ai_buffer_t* ai_memory_pool_alloc_audio_out(ai_service_type_t service_type);
+
+/**
+ * @brief 智能分配网络缓冲区
+ * @param service_type 服务类型
+ * @param size 请求大小
+ * @return ai_buffer_t* 缓冲区指针
+ */
+ai_buffer_t* ai_memory_pool_alloc_network(ai_service_type_t service_type, uint16_t size);
+
+/**
+ * @brief 智能分配连接缓冲区
+ * @param service_type 服务类型
+ * @return ai_buffer_t* 缓冲区指针
+ */
+ai_buffer_t* ai_memory_pool_alloc_connection(ai_service_type_t service_type);
+
+/* ================================ 配置辅助函数 ================================ */
+
+/**
+ * @brief 创建默认配置
+ * @param config 配置结构指针
+ */
+void ai_memory_pool_create_default_config(ai_memory_pool_config_t *config);
+
+/**
+ * @brief 获取池类型名称
+ * @param pool_type 池类型
+ * @return const char* 池类型名称
+ */
+const char* ai_memory_pool_get_type_name(ai_pool_type_t pool_type);
+
+/**
+ * @brief 计算推荐配置
+ * @param config 配置结构指针
+ * @param max_concurrent_connections 最大并发连接数
+ * @param audio_buffer_count 音频缓冲区数量
+ */
+void ai_memory_pool_calculate_recommended_config(ai_memory_pool_config_t *config,
+ uint8_t max_concurrent_connections,
+ uint8_t audio_buffer_count);
+
+/* ================================ 调试和监控函数 ================================ */
+
+/**
+ * @brief 打印内存池状态
+ * @param pool_type 池类型，AI_POOL_TYPE_COUNT表示所有池
+ */
+void ai_memory_pool_print_status(ai_pool_type_t pool_type);
+
+/**
+ * @brief 打印内存使用统计
+ */
+void ai_memory_pool_print_statistics(void);
+
+/**
+ * @brief 检查内存泄漏
+ * @return uint16_t 泄漏的缓冲区数量
+ */
+uint16_t ai_memory_pool_check_leaks(void);
+
+/**
+ * @brief 重置统计信息
+ * @param pool_type 池类型，AI_POOL_TYPE_COUNT表示所有池
+ */
+void ai_memory_pool_reset_stats(ai_pool_type_t pool_type);
+
+/**
+ * @brief 获取内存使用建议
+ * @param recommendations 建议字符串缓冲区
+ * @param buffer_size 缓冲区大小
+ */
+void ai_memory_pool_get_recommendations(char *recommendations, size_t buffer_size);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* AI_MEMORY_POOL_H */
\ No newline at end of file
+++ /dev/null
-/*
- * AI服务通用头文件
- * 定义ASR、TTS、Chat服务的通用数据结构和接口
- */
-
-#ifndef AI_SERVICE_COMMON_H
-#define AI_SERVICE_COMMON_H
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include "cmsis_os2.h"
-#include "net_websocket.h"
-#include "net_websocket_type.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* 通用配置 */
-#define AI_MAX_URL_LENGTH 256
-#define AI_MAX_MESSAGE_LENGTH 4096
-#define AI_MAX_RETRY_COUNT 3
-#define AI_CONNECT_TIMEOUT_MS 30000
-#define AI_RECEIVE_TIMEOUT_MS 10000
-#define AI_RECONNECT_INTERVAL_MS 5000
-#define AI_HEARTBEAT_INTERVAL_MS 30000
-
-/* 服务状态枚举 */
-typedef enum {
- AI_SERVICE_STATE_IDLE = 0,
- AI_SERVICE_STATE_CONNECTING,
- AI_SERVICE_STATE_CONNECTED,
- AI_SERVICE_STATE_DISCONNECTED,
- AI_SERVICE_STATE_ERROR,
- AI_SERVICE_STATE_RECONNECTING
-} ai_service_state_t;
-
-/* 错误码枚举 */
-typedef enum {
- AI_SERVICE_OK = 0,
- AI_SERVICE_ERROR_INVALID_PARAM = -1,
- AI_SERVICE_ERROR_MEMORY_ALLOC = -2,
- AI_SERVICE_ERROR_NETWORK = -3,
- AI_SERVICE_ERROR_TIMEOUT = -4,
- AI_SERVICE_ERROR_NOT_CONNECTED = -5,
- AI_SERVICE_ERROR_ALREADY_CONNECTED = -6,
- AI_SERVICE_ERROR_INTERNAL = -7
-} ai_service_error_t;
-
-/* 通用服务配置结构 */
-typedef struct {
- char server_url[AI_MAX_URL_LENGTH];
- uint16_t server_port;
- char protocol[64];
- uint32_t connect_timeout_ms;
- uint32_t receive_timeout_ms;
- uint32_t reconnect_interval_ms;
- uint32_t heartbeat_interval_ms;
- uint8_t max_retry_count;
- bool auto_reconnect;
-} ai_service_config_t;
-
-/* 通用服务统计信息 */
-typedef struct {
- uint32_t connect_count;
- uint32_t disconnect_count;
- uint32_t reconnect_count;
- uint32_t send_count;
- uint32_t receive_count;
- uint32_t error_count;
- uint32_t last_connect_time;
- uint32_t last_disconnect_time;
- uint32_t total_bytes_sent;
- uint32_t total_bytes_received;
-} ai_service_stats_t;
-
-/* 通用服务上下文结构 */
-typedef struct {
- /* 基本信息 */
- char service_name[32];
- ai_service_state_t state;
- ai_service_config_t config;
- ai_service_stats_t stats;
-
- /* WebSocket相关 */
- int ws_client_fd;
- bool is_connected;
-
- /* 线程和同步 */
- osThreadId_t service_thread;
- osThreadId_t heartbeat_thread;
- osMutexId_t mutex;
- osSemaphoreId_t connect_sem;
-
- /* 重连相关 */
- uint8_t retry_count;
- osTimerId_t reconnect_timer;
- osTimerId_t heartbeat_timer;
-
- /* 回调函数 */
- void (*on_connected)(void *context);
- void (*on_disconnected)(void *context);
- void (*on_message_received)(void *context, const char *data, size_t length);
- void (*on_error)(void *context, int error_code, const char *error_msg);
-
- /* 用户数据 */
- void *user_data;
-} ai_service_context_t;
-
-/* 通用接口函数声明 */
-
-/**
- * @brief 初始化AI服务上下文
- * @param context 服务上下文
- * @param service_name 服务名称
- * @param config 服务配置
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t ai_service_init(ai_service_context_t *context,
- const char *service_name,
- const ai_service_config_t *config);
-
-/**
- * @brief 销毁AI服务上下文
- * @param context 服务上下文
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t ai_service_destroy(ai_service_context_t *context);
-
-/**
- * @brief 启动AI服务
- * @param context 服务上下文
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t ai_service_start(ai_service_context_t *context);
-
-/**
- * @brief 停止AI服务
- * @param context 服务上下文
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t ai_service_stop(ai_service_context_t *context);
-
-/**
- * @brief 连接到服务器
- * @param context 服务上下文
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t ai_service_connect(ai_service_context_t *context);
-
-/**
- * @brief 断开连接
- * @param context 服务上下文
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t ai_service_disconnect(ai_service_context_t *context);
-
-/**
- * @brief 发送数据
- * @param context 服务上下文
- * @param data 数据内容
- * @param length 数据长度
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t ai_service_send_data(ai_service_context_t *context,
- const char *data, size_t length);
-
-/**
- * @brief 发送文本消息
- * @param context 服务上下文
- * @param text 文本内容
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t ai_service_send_text(ai_service_context_t *context, const char *text);
-
-/**
- * @brief 发送二进制数据
- * @param context 服务上下文
- * @param data 二进制数据
- * @param length 数据长度
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t ai_service_send_binary(ai_service_context_t *context,
- const char *data, size_t length);
-
-/**
- * @brief 检查连接状态
- * @param context 服务上下文
- * @return true 已连接，false 未连接
- */
-bool ai_service_is_connected(ai_service_context_t *context);
-
-/**
- * @brief 获取服务状态
- * @param context 服务上下文
- * @return 当前服务状态
- */
-ai_service_state_t ai_service_get_state(ai_service_context_t *context);
-
-/**
- * @brief 获取服务统计信息
- * @param context 服务上下文
- * @return 统计信息指针
- */
-const ai_service_stats_t* ai_service_get_stats(ai_service_context_t *context);
-
-/**
- * @brief 设置回调函数
- * @param context 服务上下文
- * @param on_connected 连接成功回调
- * @param on_disconnected 断开连接回调
- * @param on_message_received 消息接收回调
- * @param on_error 错误回调
- */
-void ai_service_set_callbacks(ai_service_context_t *context,
- void (*on_connected)(void *context),
- void (*on_disconnected)(void *context),
- void (*on_message_received)(void *context, const char *data, size_t length),
- void (*on_error)(void *context, int error_code, const char *error_msg));
-
-/**
- * @brief 设置用户数据
- * @param context 服务上下文
- * @param user_data 用户数据指针
- */
-void ai_service_set_user_data(ai_service_context_t *context, void *user_data);
-
-/**
- * @brief 获取用户数据
- * @param context 服务上下文
- * @return 用户数据指针
- */
-void* ai_service_get_user_data(ai_service_context_t *context);
-
-/* 工具函数 */
-
-/**
- * @brief 获取当前时间戳（毫秒）
- * @return 时间戳
- */
-uint32_t ai_service_get_timestamp(void);
-
-/**
- * @brief 生成UUID字符串
- * @param uuid_str 输出缓冲区
- * @param max_len 缓冲区最大长度
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t ai_service_generate_uuid(char *uuid_str, size_t max_len);
-
-/**
- * @brief 创建JSON消息
- * @param type 消息类型
- * @param data 消息数据
- * @param output 输出缓冲区
- * @param max_len 缓冲区最大长度
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t ai_service_create_json_message(const char *type,
- const char *data,
- char *output,
- size_t max_len);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* AI_SERVICE_COMMON_H */
\ No newline at end of file
+++ /dev/null
-/*
- * Copyright (c) CompanyNameMagicTag. 2023-2023. All rights reserved.
- * Description: AI Service Manager - AI全家桶总入口
- * Author: AI Development Team
- * Create: 2024-12-28
- */
-
-#ifndef AI_SERVICE_MANAGER_H
-#define AI_SERVICE_MANAGER_H
-
-#include <stdint.h>
-#include <stdbool.h>
-#include "ai_service_common.h"
-#include "asr_server.h"
-#include "chat_server.h"
-#include "tts_server.h"
-#include "ai_media.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* ==================== 宏定义 ==================== */
-
-#define AI_MANAGER_MAX_SESSION_ID_LEN 64
-#define AI_MANAGER_MAX_TEXT_LEN 4096
-#define AI_MANAGER_MAX_RETRY_COUNT 3
-
-/* ==================== 枚举定义 ==================== */
-
-/**
- * @brief AI服务管理器状态
- */
-typedef enum {
- AI_MANAGER_STATE_IDLE = 0, // 空闲状态
- AI_MANAGER_STATE_INITIALIZING, // 初始化中
- AI_MANAGER_STATE_READY, // 就绪状态
- AI_MANAGER_STATE_LISTENING, // 监听中（ASR激活）
- AI_MANAGER_STATE_PROCESSING, // 处理中（Chat处理）
- AI_MANAGER_STATE_SPEAKING, // 播放中（TTS播放）
- AI_MANAGER_STATE_ERROR, // 错误状态
- AI_MANAGER_STATE_SHUTDOWN // 关闭状态
-} ai_manager_state_t;
-
-/**
- * @brief AI交互事件类型
- */
-typedef enum {
- AI_EVENT_CONVERSATION_START = 0, // 对话开始
- AI_EVENT_SPEECH_START, // 语音开始
- AI_EVENT_SPEECH_PARTIAL, // 语音识别中间结果
- AI_EVENT_SPEECH_END, // 语音结束
- AI_EVENT_CHAT_RESPONSE_START, // Chat回复开始
- AI_EVENT_CHAT_RESPONSE_PARTIAL, // Chat回复中间结果
- AI_EVENT_CHAT_RESPONSE_END, // Chat回复结束
- AI_EVENT_TTS_START, // TTS开始
- AI_EVENT_TTS_END, // TTS结束
- AI_EVENT_CONVERSATION_END, // 对话结束
- AI_EVENT_ERROR // 错误事件
-} ai_event_type_t;
-
-/**
- * @brief AI服务类型
- */
-typedef enum {
- AI_SERVICE_TYPE_ASR = 0,
- AI_SERVICE_TYPE_CHAT,
- AI_SERVICE_TYPE_TTS,
- AI_SERVICE_TYPE_ALL
-} ai_service_type_t;
-
-/* ==================== 结构体定义 ==================== */
-
-/**
- * @brief AI事件数据结构
- */
-typedef struct {
- ai_event_type_t type;
- char session_id[AI_MANAGER_MAX_SESSION_ID_LEN];
- char *text; // 文本内容（可选）
- uint32_t text_length; // 文本长度
- float confidence; // 置信度（ASR使用）
- bool is_final; // 是否为最终结果
- uint32_t timestamp; // 时间戳
- int error_code; // 错误码（错误事件使用）
- char *error_message; // 错误信息（错误事件使用）
-} ai_event_data_t;
-
-/**
- * @brief AI服务配置
- */
-typedef struct {
- /* ASR配置 */
- char asr_server_url[AI_MAX_URL_LENGTH];
- uint16_t asr_server_port;
- asr_audio_config_t asr_audio_config;
- asr_recognition_config_t asr_recognition_config;
-
- /* Chat配置 */
- char chat_server_url[AI_MAX_URL_LENGTH];
- uint16_t chat_server_port;
- chat_model_config_t chat_model_config;
-
- /* TTS配置 */
- char tts_server_url[AI_MAX_URL_LENGTH];
- uint16_t tts_server_port;
- tts_audio_config_t tts_audio_config;
- tts_voice_config_t tts_voice_config;
-
- /* 通用配置 */
- uint32_t connect_timeout_ms;
- uint32_t response_timeout_ms;
- bool auto_reconnect;
- uint8_t max_retry_count;
-} ai_manager_config_t;
-
-/**
- * @brief AI服务统计信息
- */
-typedef struct {
- uint32_t conversation_count; // 对话次数
- uint32_t asr_recognition_count; // ASR识别次数
- uint32_t chat_request_count; // Chat请求次数
- uint32_t tts_synthesis_count; // TTS合成次数
- uint32_t total_errors; // 总错误数
- uint32_t last_conversation_time; // 最后对话时间
- float avg_response_time_ms; // 平均响应时间
-} ai_manager_stats_t;
-
-/**
- * @brief AI服务管理器上下文
- */
-typedef struct {
- /* 基本信息 */
- ai_manager_state_t state;
- ai_manager_config_t config;
- ai_manager_stats_t stats;
-
- /* 服务实例 */
- asr_server_context_t *asr_context;
- chat_server_context_t *chat_context;
- tts_server_context_t *tts_context;
-
- /* 当前会话信息 */
- char current_session_id[AI_MANAGER_MAX_SESSION_ID_LEN];
- bool is_conversation_active;
- bool is_recording_active;
- bool is_playback_active;
-
- /* 线程和同步 */
- osThreadId_t manager_thread;
- osMutexId_t mutex;
- osMessageQueueId_t event_queue;
-
- /* 回调函数 */
- void (*on_event)(void *user_data, const ai_event_data_t *event);
- void *user_data;
-
- /* 内部状态 */
- uint32_t init_timestamp;
- bool services_initialized;
-} ai_manager_context_t;
-
-/* ==================== 回调函数类型定义 ==================== */
-
-/**
- * @brief AI事件回调函数类型
- * @param user_data 用户数据
- * @param event 事件数据
- */
-typedef void (*ai_event_callback_t)(void *user_data, const ai_event_data_t *event);
-
-/* ==================== 公共接口函数 ==================== */
-
-/**
- * @brief 初始化AI服务管理器
- * @param context AI管理器上下文
- * @param config AI服务配置
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t ai_manager_init(ai_manager_context_t *context,
- const ai_manager_config_t *config);
-
-/**
- * @brief 销毁AI服务管理器
- * @param context AI管理器上下文
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t ai_manager_destroy(ai_manager_context_t *context);
-
-/**
- * @brief 启动AI服务
- * @param context AI管理器上下文
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t ai_manager_start(ai_manager_context_t *context);
-
-/**
- * @brief 停止AI服务
- * @param context AI管理器上下文
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t ai_manager_stop(ai_manager_context_t *context);
-
-/**
- * @brief 开始对话
- * @param context AI管理器上下文
- * @param session_id 会话ID（可选，传NULL自动生成）
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t ai_manager_start_conversation(ai_manager_context_t *context,
- const char *session_id);
-
-/**
- * @brief 结束对话
- * @param context AI管理器上下文
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t ai_manager_end_conversation(ai_manager_context_t *context);
-
-/**
- * @brief 开始语音输入
- * @param context AI管理器上下文
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t ai_manager_start_speech_input(ai_manager_context_t *context);
-
-/**
- * @brief 停止语音输入
- * @param context AI管理器上下文
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t ai_manager_stop_speech_input(ai_manager_context_t *context);
-
-/**
- * @brief 发送文本消息到Chat
- * @param context AI管理器上下文
- * @param text 文本内容
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t ai_manager_send_text_message(ai_manager_context_t *context,
- const char *text);
-
-/**
- * @brief 停止当前TTS播放
- * @param context AI管理器上下文
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t ai_manager_stop_tts_playback(ai_manager_context_t *context);
-
-/**
- * @brief 设置事件回调函数
- * @param context AI管理器上下文
- * @param callback 回调函数
- * @param user_data 用户数据
- */
-void ai_manager_set_event_callback(ai_manager_context_t *context,
- ai_event_callback_t callback,
- void *user_data);
-
-/**
- * @brief 获取当前状态
- * @param context AI管理器上下文
- * @return 当前状态
- */
-ai_manager_state_t ai_manager_get_state(ai_manager_context_t *context);
-
-/**
- * @brief 获取统计信息
- * @param context AI管理器上下文
- * @return 统计信息指针
- */
-const ai_manager_stats_t* ai_manager_get_stats(ai_manager_context_t *context);
-
-/**
- * @brief 检查服务是否就绪
- * @param context AI管理器上下文
- * @param service_type 服务类型
- * @return true 就绪，false 未就绪
- */
-bool ai_manager_is_service_ready(ai_manager_context_t *context,
- ai_service_type_t service_type);
-
-/* ==================== 工具函数 ==================== */
-
-/**
- * @brief 创建默认配置
- * @param config 配置结构体指针
- */
-void ai_manager_create_default_config(ai_manager_config_t *config);
-
-/**
- * @brief 生成会话ID
- * @param session_id 输出缓冲区
- * @param max_len 缓冲区最大长度
- */
-void ai_manager_generate_session_id(char *session_id, size_t max_len);
-
-/**
- * @brief 状态转换为字符串
- * @param state 状态
- * @return 状态字符串
- */
-const char* ai_manager_state_to_string(ai_manager_state_t state);
-
-/**
- * @brief 事件类型转换为字符串
- * @param event_type 事件类型
- * @return 事件类型字符串
- */
-const char* ai_manager_event_type_to_string(ai_event_type_t event_type);
-
-/**
- * @brief 释放事件数据
- * @param event 事件数据指针
- */
-void ai_manager_free_event_data(ai_event_data_t *event);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* AI_SERVICE_MANAGER_H */
\ No newline at end of file
--- /dev/null
+/**
+ * @file ai_services.h
+ * @brief AI服务统一接口 - LiteOS-M优化版v2
+ * @version 2.0
+ * @date 2024-01-20
+ *
+ * 统一AI服务接口：
+ * - ASR语音识别服务
+ * - Chat对话服务
+ * - TTS语音合成服务
+ * - 轻量化设计，适配LiteOS-M
+ */
+
+#ifndef AI_SERVICES_H
+#define AI_SERVICES_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "ai_core_types.h"
+
+/* ================================ ASR服务定义 ================================ */
+
+typedef enum {
+ ASR_STATE_IDLE = 0, // 空闲状态
+ ASR_STATE_LISTENING, // 监听中
+ ASR_STATE_RECOGNIZING, // 识别中
+ ASR_STATE_COMPLETED, // 识别完成
+ ASR_STATE_ERROR // 错误状态
+} asr_state_t;
+
+typedef struct {
+ char session_id[AI_MAX_SESSION_ID_LENGTH]; // 会话ID
+ char text[AI_MAX_TEXT_LENGTH]; // 识别文本
+ float confidence; // 置信度 (0.0-1.0)
+ bool is_final; // 是否最终结果
+ bool is_partial; // 是否部分结果
+ uint32_t start_time_ms; // 开始时间
+ uint32_t end_time_ms; // 结束时间
+ uint32_t duration_ms; // 持续时间
+} asr_result_t;
+
+typedef struct {
+ bool enable_vad; // 启用语音活动检测
+ bool enable_punctuation; // 启用标点符号
+ bool enable_partial_results; // 启用部分结果
+ uint16_t silence_timeout_ms; // 静音超时时间
+ uint16_t max_duration_ms; // 最大录音时长
+ char language[8]; // 语言代码 "zh-CN"
+} asr_config_t;
+
+/* ASR回调函数类型 */
+typedef void (*asr_result_callback_t)(const asr_result_t *result, void *user_data);
+typedef void (*asr_error_callback_t)(int error_code, const char *error_msg, void *user_data);
+typedef void (*asr_state_callback_t)(asr_state_t old_state, asr_state_t new_state, void *user_data);
+
+/* ================================ Chat服务定义 ================================ */
+
+typedef enum {
+ CHAT_STATE_IDLE = 0, // 空闲状态
+ CHAT_STATE_SENDING, // 发送中
+ CHAT_STATE_WAITING, // 等待响应
+ CHAT_STATE_RECEIVING, // 接收中
+ CHAT_STATE_COMPLETED, // 完成
+ CHAT_STATE_ERROR // 错误状态
+} chat_state_t;
+
+typedef enum {
+ CHAT_ROLE_USER = 0, // 用户角色
+ CHAT_ROLE_ASSISTANT, // 助手角色
+ CHAT_ROLE_SYSTEM // 系统角色
+} chat_role_t;
+
+typedef struct {
+ char session_id[AI_MAX_SESSION_ID_LENGTH]; // 会话ID
+ char message_id[32]; // 消息ID
+ chat_role_t role; // 角色
+ char content[AI_MAX_TEXT_LENGTH]; // 消息内容
+ uint32_t timestamp; // 时间戳
+ bool is_streaming; // 是否流式响应
+ bool is_final; // 是否最终响应
+} chat_message_t;
+
+typedef struct {
+ char model_name[32]; // 模型名称
+ float temperature; // 温度参数 (0.0-2.0)
+ uint16_t max_tokens; // 最大令牌数
+ float top_p; // Top-p参数
+ bool stream; // 流式输出
+ uint16_t timeout_ms; // 超时时间
+} chat_config_t;
+
+/* Chat回调函数类型 */
+typedef void (*chat_response_callback_t)(const chat_message_t *message, void *user_data);
+typedef void (*chat_error_callback_t)(int error_code, const char *error_msg, void *user_data);
+typedef void (*chat_state_callback_t)(chat_state_t old_state, chat_state_t new_state, void *user_data);
+
+/* ================================ TTS服务定义 ================================ */
+
+typedef enum {
+ TTS_STATE_IDLE = 0, // 空闲状态
+ TTS_STATE_SYNTHESIZING, // 合成中
+ TTS_STATE_PLAYING, // 播放中
+ TTS_STATE_COMPLETED, // 完成
+ TTS_STATE_ERROR // 错误状态
+} tts_state_t;
+
+typedef enum {
+ TTS_VOICE_XIAOYUN = 0, // 小云
+ TTS_VOICE_XIAOGANG, // 小刚
+ TTS_VOICE_XIAOMEI, // 小美
+ TTS_VOICE_XIAOLI, // 小丽
+ TTS_VOICE_COUNT // 语音总数
+} tts_voice_type_t;
+
+typedef struct {
+ char session_id[AI_MAX_SESSION_ID_LENGTH]; // 会话ID
+ uint8_t *audio_data; // 音频数据
+ uint32_t audio_size; // 音频大小
+ uint32_t sample_rate; // 采样率
+ uint8_t channels; // 声道数
+ uint8_t bits_per_sample; // 位深度
+ bool is_final; // 是否最终数据
+ uint32_t sequence; // 序列号
+} tts_result_t;
+
+typedef struct {
+ tts_voice_type_t voice_type; // 语音类型
+ uint8_t volume; // 音量 (0-100)
+ uint8_t speed; // 语速 (0-100, 50为正常)
+ uint8_t pitch; // 音调 (0-100, 50为正常)
+ bool auto_play; // 自动播放
+ uint16_t timeout_ms; // 超时时间
+} tts_config_t;
+
+/* TTS回调函数类型 */
+typedef void (*tts_result_callback_t)(const tts_result_t *result, void *user_data);
+typedef void (*tts_error_callback_t)(int error_code, const char *error_msg, void *user_data);
+typedef void (*tts_state_callback_t)(tts_state_t old_state, tts_state_t new_state, void *user_data);
+
+/* ================================ 服务上下文结构 ================================ */
+
+typedef struct {
+ ai_service_type_t service_type; // 服务类型
+ asr_state_t asr_state; // ASR状态
+ chat_state_t chat_state; // Chat状态
+ tts_state_t tts_state; // TTS状态
+
+ asr_config_t asr_config; // ASR配置
+ chat_config_t chat_config; // Chat配置
+ tts_config_t tts_config; // TTS配置
+
+ /* ASR回调 */
+ asr_result_callback_t asr_result_cb;
+ asr_error_callback_t asr_error_cb;
+ asr_state_callback_t asr_state_cb;
+
+ /* Chat回调 */
+ chat_response_callback_t chat_response_cb;
+ chat_error_callback_t chat_error_cb;
+ chat_state_callback_t chat_state_cb;
+
+ /* TTS回调 */
+ tts_result_callback_t tts_result_cb;
+ tts_error_callback_t tts_error_cb;
+ tts_state_callback_t tts_state_cb;
+
+ void *user_data; // 用户数据
+
+ /* 内部状态 */
+ char current_session_id[AI_MAX_SESSION_ID_LENGTH]; // 当前会话ID
+ uint32_t last_activity_time; // 最后活动时间
+ bool is_initialized; // 初始化标志
+} ai_services_context_t;
+
+/* ================================ 公共接口函数 ================================ */
+
+/**
+ * @brief 初始化AI服务
+ * @param context 服务上下文
+ * @return ai_error_t 错误码
+ */
+ai_error_t ai_services_init(ai_services_context_t *context);
+
+/**
+ * @brief 销毁AI服务
+ * @param context 服务上下文
+ * @return ai_error_t 错误码
+ */
+ai_error_t ai_services_destroy(ai_services_context_t *context);
+
+/* ================================ ASR服务接口 ================================ */
+
+/**
+ * @brief 配置ASR服务
+ * @param context 服务上下文
+ * @param config ASR配置
+ * @return ai_error_t 错误码
+ */
+ai_error_t ai_asr_configure(ai_services_context_t *context, const asr_config_t *config);
+
+/**
+ * @brief 设置ASR回调函数
+ * @param context 服务上下文
+ * @param result_cb 结果回调
+ * @param error_cb 错误回调
+ * @param state_cb 状态回调
+ * @param user_data 用户数据
+ * @return ai_error_t 错误码
+ */
+ai_error_t ai_asr_set_callbacks(ai_services_context_t *context,
+ asr_result_callback_t result_cb,
+ asr_error_callback_t error_cb,
+ asr_state_callback_t state_cb,
+ void *user_data);
+
+/**
+ * @brief 开始语音识别
+ * @param context 服务上下文
+ * @param session_id 会话ID，NULL则自动生成
+ * @return ai_error_t 错误码
+ */
+ai_error_t ai_asr_start(ai_services_context_t *context, const char *session_id);
+
+/**
+ * @brief 发送音频数据
+ * @param context 服务上下文
+ * @param audio_data 音频数据
+ * @param data_size 数据大小
+ * @return ai_error_t 错误码
+ */
+ai_error_t ai_asr_send_audio(ai_services_context_t *context, const uint8_t *audio_data, uint32_t data_size);
+
+/**
+ * @brief 停止语音识别
+ * @param context 服务上下文
+ * @return ai_error_t 错误码
+ */
+ai_error_t ai_asr_stop(ai_services_context_t *context);
+
+/**
+ * @brief 获取ASR状态
+ * @param context 服务上下文
+ * @return asr_state_t ASR状态
+ */
+asr_state_t ai_asr_get_state(ai_services_context_t *context);
+
+/* ================================ Chat服务接口 ================================ */
+
+/**
+ * @brief 配置Chat服务
+ * @param context 服务上下文
+ * @param config Chat配置
+ * @return ai_error_t 错误码
+ */
+ai_error_t ai_chat_configure(ai_services_context_t *context, const chat_config_t *config);
+
+/**
+ * @brief 设置Chat回调函数
+ * @param context 服务上下文
+ * @param response_cb 响应回调
+ * @param error_cb 错误回调
+ * @param state_cb 状态回调
+ * @param user_data 用户数据
+ * @return ai_error_t 错误码
+ */
+ai_error_t ai_chat_set_callbacks(ai_services_context_t *context,
+ chat_response_callback_t response_cb,
+ chat_error_callback_t error_cb,
+ chat_state_callback_t state_cb,
+ void *user_data);
+
+/**
+ * @brief 发送聊天消息
+ * @param context 服务上下文
+ * @param message 消息内容
+ * @param session_id 会话ID，NULL则使用当前会话
+ * @return ai_error_t 错误码
+ */
+ai_error_t ai_chat_send_message(ai_services_context_t *context, const char *message, const char *session_id);
+
+/**
+ * @brief 获取Chat状态
+ * @param context 服务上下文
+ * @return chat_state_t Chat状态
+ */
+chat_state_t ai_chat_get_state(ai_services_context_t *context);
+
+/* ================================ TTS服务接口 ================================ */
+
+/**
+ * @brief 配置TTS服务
+ * @param context 服务上下文
+ * @param config TTS配置
+ * @return ai_error_t 错误码
+ */
+ai_error_t ai_tts_configure(ai_services_context_t *context, const tts_config_t *config);
+
+/**
+ * @brief 设置TTS回调函数
+ * @param context 服务上下文
+ * @param result_cb 结果回调
+ * @param error_cb 错误回调
+ * @param state_cb 状态回调
+ * @param user_data 用户数据
+ * @return ai_error_t 错误码
+ */
+ai_error_t ai_tts_set_callbacks(ai_services_context_t *context,
+ tts_result_callback_t result_cb,
+ tts_error_callback_t error_cb,
+ tts_state_callback_t state_cb,
+ void *user_data);
+
+/**
+ * @brief 开始语音合成
+ * @param context 服务上下文
+ * @param text 待合成文本
+ * @param session_id 会话ID，NULL则自动生成
+ * @return ai_error_t 错误码
+ */
+ai_error_t ai_tts_synthesize(ai_services_context_t *context, const char *text, const char *session_id);
+
+/**
+ * @brief 停止语音合成
+ * @param context 服务上下文
+ * @return ai_error_t 错误码
+ */
+ai_error_t ai_tts_stop(ai_services_context_t *context);
+
+/**
+ * @brief 获取TTS状态
+ * @param context 服务上下文
+ * @return tts_state_t TTS状态
+ */
+tts_state_t ai_tts_get_state(ai_services_context_t *context);
+
+/* ================================ 辅助函数 ================================ */
+
+/**
+ * @brief 创建默认ASR配置
+ * @param config ASR配置结构指针
+ */
+void ai_asr_create_default_config(asr_config_t *config);
+
+/**
+ * @brief 创建默认Chat配置
+ * @param config Chat配置结构指针
+ */
+void ai_chat_create_default_config(chat_config_t *config);
+
+/**
+ * @brief 创建默认TTS配置
+ * @param config TTS配置结构指针
+ */
+void ai_tts_create_default_config(tts_config_t *config);
+
+/**
+ * @brief 生成会话ID
+ * @param session_id 输出缓冲区
+ * @param buffer_size 缓冲区大小
+ */
+void ai_services_generate_session_id(char *session_id, size_t buffer_size);
+
+/**
+ * @brief 获取语音类型名称
+ * @param voice_type 语音类型
+ * @return const char* 语音名称
+ */
+const char* ai_tts_get_voice_name(tts_voice_type_t voice_type);
+
+/**
+ * @brief 获取服务状态字符串
+ * @param service_type 服务类型
+ * @param context 服务上下文
+ * @return const char* 状态字符串
+ */
+const char* ai_services_get_state_string(ai_service_type_t service_type, ai_services_context_t *context);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* AI_SERVICES_H */
\ No newline at end of file
+++ /dev/null
-/*
- * ASR (Automatic Speech Recognition) 服务头文件
- * 负责建立与ASR服务器的WebSocket连接管理，上传录音数据，接收识别结果
- */
-
-#ifndef ASR_SERVER_H
-#define ASR_SERVER_H
-
-#include "ai_service_common.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* ASR特定配置 */
-#define ASR_MAX_AUDIO_BUFFER_SIZE 8192
-#define ASR_SAMPLE_RATE_DEFAULT 16000
-#define ASR_CHANNELS_DEFAULT 1
-#define ASR_BITS_PER_SAMPLE_DEFAULT 16
-#define ASR_FRAME_SIZE_MS_DEFAULT 20
-
-/* ASR音频格式枚举 */
-typedef enum {
- ASR_AUDIO_FORMAT_PCM = 0,
- ASR_AUDIO_FORMAT_WAV,
- ASR_AUDIO_FORMAT_MP3,
- ASR_AUDIO_FORMAT_OPUS
-} asr_audio_format_t;
-
-/* ASR识别模式枚举 */
-typedef enum {
- ASR_MODE_CONTINUOUS = 0, // 连续识别
- ASR_MODE_SINGLE_SHOT, // 单次识别
- ASR_MODE_STREAMING // 流式识别
-} asr_recognition_mode_t;
-
-/* ASR语言枚举 */
-typedef enum {
- ASR_LANGUAGE_ZH_CN = 0, // 中文
- ASR_LANGUAGE_EN_US, // 英文
- ASR_LANGUAGE_AUTO // 自动检测
-} asr_language_t;
-
-/* ASR音频配置 */
-typedef struct {
- asr_audio_format_t format;
- uint32_t sample_rate;
- uint8_t channels;
- uint8_t bits_per_sample;
- uint16_t frame_size_ms;
-} asr_audio_config_t;
-
-/* ASR识别配置 */
-typedef struct {
- asr_recognition_mode_t mode;
- asr_language_t language;
- bool enable_punctuation;
- bool enable_word_timestamp;
- bool enable_confidence_score;
- uint32_t max_silence_ms;
- uint32_t max_speech_ms;
-} asr_recognition_config_t;
-
-/* ASR识别结果 */
-typedef struct {
- char *text; // 识别文本
- float confidence; // 置信度 (0.0-1.0)
- bool is_final; // 是否为最终结果
- uint32_t start_time_ms; // 开始时间
- uint32_t end_time_ms; // 结束时间
- char *session_id; // 会话ID
-} asr_recognition_result_t;
-
-/* ASR服务上下文 */
-typedef struct {
- ai_service_context_t base; // 基础服务上下文
-
- /* ASR特定配置 */
- asr_audio_config_t audio_config;
- asr_recognition_config_t recognition_config;
-
- /* 音频缓冲区 */
- char *audio_buffer;
- size_t audio_buffer_size;
- size_t audio_buffer_used;
- osMutexId_t audio_buffer_mutex;
-
- /* 会话管理 */
- char current_session_id[64];
- bool session_active;
-
- /* 回调函数 */
- void (*on_recognition_result)(void *context, const asr_recognition_result_t *result);
- void (*on_recognition_start)(void *context, const char *session_id);
- void (*on_recognition_end)(void *context, const char *session_id);
- void (*on_audio_level)(void *context, float level);
-
- /* 统计信息 */
- uint32_t total_audio_sent;
- uint32_t total_results_received;
- uint32_t recognition_sessions;
-} asr_server_context_t;
-
-/* ASR服务接口函数 */
-
-/**
- * @brief 初始化ASR服务
- * @param context ASR服务上下文
- * @param server_url 服务器URL
- * @param audio_config 音频配置
- * @param recognition_config 识别配置
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t asr_server_init(asr_server_context_t *context,
- const char *server_url,
- const asr_audio_config_t *audio_config,
- const asr_recognition_config_t *recognition_config);
-
-/**
- * @brief 销毁ASR服务
- * @param context ASR服务上下文
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t asr_server_destroy(asr_server_context_t *context);
-
-/**
- * @brief 启动ASR服务
- * @param context ASR服务上下文
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t asr_server_start(asr_server_context_t *context);
-
-/**
- * @brief 停止ASR服务
- * @param context ASR服务上下文
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t asr_server_stop(asr_server_context_t *context);
-
-/**
- * @brief 开始语音识别会话
- * @param context ASR服务上下文
- * @param session_id 会话ID（可选，为NULL时自动生成）
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t asr_server_start_recognition(asr_server_context_t *context,
- const char *session_id);
-
-/**
- * @brief 结束语音识别会话
- * @param context ASR服务上下文
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t asr_server_stop_recognition(asr_server_context_t *context);
-
-
-
-/**
- * @brief 发送音频数据（流式）
- * @param context ASR服务上下文
- * @param audio_data 音频数据
- * @param data_length 数据长度
- * @param is_last 是否为最后一帧
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t asr_server_send_audio_stream(asr_server_context_t *context,
- const char *audio_data,
- size_t data_length,
- bool is_last);
-
-/**
- * @brief 设置音频配置
- * @param context ASR服务上下文
- * @param audio_config 音频配置
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t asr_server_set_audio_config(asr_server_context_t *context,
- const asr_audio_config_t *audio_config);
-
-/**
- * @brief 设置识别配置
- * @param context ASR服务上下文
- * @param recognition_config 识别配置
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t asr_server_set_recognition_config(asr_server_context_t *context,
- const asr_recognition_config_t *recognition_config);
-
-/**
- * @brief 获取当前会话ID
- * @param context ASR服务上下文
- * @return 会话ID字符串，NULL表示无活动会话
- */
-const char* asr_server_get_current_session_id(asr_server_context_t *context);
-
-/**
- * @brief 检查是否有活动的识别会话
- * @param context ASR服务上下文
- * @return true 有活动会话，false 无活动会话
- */
-bool asr_server_is_recognition_active(asr_server_context_t *context);
-
-/**
- * @brief 设置ASR回调函数
- * @param context ASR服务上下文
- * @param on_recognition_result 识别结果回调
- * @param on_recognition_start 识别开始回调
- * @param on_recognition_end 识别结束回调
- * @param on_audio_level 音频电平回调
- */
-void asr_server_set_callbacks(asr_server_context_t *context,
- void (*on_recognition_result)(void *context, const asr_recognition_result_t *result),
- void (*on_recognition_start)(void *context, const char *session_id),
- void (*on_recognition_end)(void *context, const char *session_id),
- void (*on_audio_level)(void *context, float level));
-
-/**
- * @brief 获取ASR统计信息
- * @param context ASR服务上下文
- * @param total_audio_sent 总发送音频字节数
- * @param total_results_received 总接收结果数
- * @param recognition_sessions 识别会话数
- */
-void asr_server_get_stats(asr_server_context_t *context,
- uint32_t *total_audio_sent,
- uint32_t *total_results_received,
- uint32_t *recognition_sessions);
-
-/* 工具函数 */
-
-/**
- * @brief 创建默认音频配置
- * @param config 输出配置
- */
-void asr_server_create_default_audio_config(asr_audio_config_t *config);
-
-/**
- * @brief 创建默认识别配置
- * @param config 输出配置
- */
-void asr_server_create_default_recognition_config(asr_recognition_config_t *config);
-
-/**
- * @brief 释放识别结果内存
- * @param result 识别结果
- */
-void asr_server_free_recognition_result(asr_recognition_result_t *result);
-
-/**
- * @brief 音频格式转字符串
- * @param format 音频格式
- * @return 格式字符串
- */
-const char* asr_server_audio_format_to_string(asr_audio_format_t format);
-
-/**
- * @brief 识别模式转字符串
- * @param mode 识别模式
- * @return 模式字符串
- */
-const char* asr_server_recognition_mode_to_string(asr_recognition_mode_t mode);
-
-/**
- * @brief 语言转字符串
- * @param language 语言
- * @return 语言字符串
- */
-const char* asr_server_language_to_string(asr_language_t language);
-
-/* ASR API 函数 */
-
-/**
- * @brief 初始化ASR WebSocket URL
- * @param put_buf 输出缓冲区，存储构建的URL
- * @return bool true表示成功，false表示失败
- */
-bool asr_api_ws_url_init(char *put_buf);
-
-/**
- * @brief ASR结果分析函数
- * @param buf 接收到的JSON字符串缓冲区
- * @param result 输出的识别结果结构体
- * @return bool true表示解析成功，false表示解析失败
- */
-bool asr_api_result_analysis(char *buf, asr_recognition_result_t *result);
-
-/**
- * @brief 启动ASR（语音识别）服务
- * @param context ASR服务上下文
- */
-void asr_api_start_asr(asr_server_context_t *context);
-
-/**
- * @brief 停止ASR（语音识别）服务
- * @param context ASR服务上下文
- */
-void asr_api_stop_asr(asr_server_context_t *context);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* ASR_SERVER_H */
\ No newline at end of file
+++ /dev/null
-/*
- * Chat 大模型服务头文件
- * 负责建立与Chat大模型服务器的WebSocket连接管理，上传文本，接收回复并转发给TTS
- */
-
-#ifndef CHAT_SERVER_H
-#define CHAT_SERVER_H
-
-#include "ai_service_common.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Chat特定配置 */
-#define CHAT_MAX_MESSAGE_LENGTH 4096
-#define CHAT_MAX_CONTEXT_LENGTH 16384
-#define CHAT_MAX_MODEL_NAME_LENGTH 64
-#define CHAT_MAX_HISTORY_COUNT 50
-
-/* Chat消息类型枚举 */
-typedef enum {
- CHAT_MESSAGE_TYPE_TEXT = 0,
- CHAT_MESSAGE_TYPE_IMAGE,
- CHAT_MESSAGE_TYPE_AUDIO,
- CHAT_MESSAGE_TYPE_VIDEO,
- CHAT_MESSAGE_TYPE_SYSTEM
-} chat_message_type_t;
-
-
-/* Chat消息角色枚举 */
-typedef enum {
- CHAT_ROLE_USER = 0,
- CHAT_ROLE_ASSISTANT,
- CHAT_ROLE_SYSTEM
-} chat_role_t;
-
-/* Chat模型类型枚举 */
-typedef enum {
- CHAT_MODEL_TYPE_GPT35 = 0,
- CHAT_MODEL_TYPE_GPT4,
- CHAT_MODEL_TYPE_CLAUDE,
- CHAT_MODEL_TYPE_LLAMA,
- CHAT_MODEL_TYPE_QWEN,
- CHAT_MODEL_TYPE_BAICHUAN
-} chat_model_type_t;
-typedef enum
-{
- AI_TYPE_0=0,
- AI_TYPE_JIU, //九天
- AI_TYPE_DE, //deepseek
- AI_TYPE_DOU,//豆包
- AI_TYPE_WEN,//文心一言
- AI_TYPE_KIMI,//KIMI
-}G_AI_TYPE;
-/* Chat响应模式枚举 */
-typedef enum {
- CHAT_RESPONSE_MODE_COMPLETE = 0, // 完整响应
- CHAT_RESPONSE_MODE_STREAMING // 流式响应
-} chat_response_mode_t;
-
-/* Chat消息结构 */
-typedef struct {
- chat_role_t role;
- chat_message_type_t type;
- char *content;
- size_t content_length;
- uint32_t timestamp;
- char message_id[64];
-} chat_message_t;
-
-/* Chat会话历史 */
-typedef struct {
- chat_message_t *messages;
- size_t message_count;
- size_t max_messages;
- char session_id[64];
- uint32_t created_time;
- uint32_t last_update_time;
-} chat_conversation_t;
-
-/* Chat模型配置 */
-typedef struct {
- char model_name[CHAT_MAX_MODEL_NAME_LENGTH];
- chat_model_type_t model_type;
- float temperature; // 温度参数 (0.0-2.0)
- float top_p; // Top-p参数 (0.0-1.0)
- uint32_t max_tokens; // 最大token数
- bool enable_history; // 是否启用历史记录
- uint32_t max_history_count; // 最大历史记录数
-} chat_model_config_t;
-
-/* Chat请求结构 */
-typedef struct {
- char *message;
- chat_message_type_t message_type;
- char session_id[64];
- chat_response_mode_t response_mode;
- chat_model_config_t model_config;
- bool include_history;
-} chat_request_t;
-
-/* Chat响应结构 */
-typedef struct {
- char *content;
- size_t content_length;
- char session_id[64];
- char message_id[64];
- bool is_final;
- bool is_streaming;
- uint32_t token_count;
- float confidence;
- uint32_t response_time_ms;
-} chat_response_t;
-
-/* Chat统计信息 */
-typedef struct {
- uint32_t total_requests;
- uint32_t total_responses;
- uint32_t total_tokens_sent;
- uint32_t total_tokens_received;
- uint32_t average_response_time_ms;
- uint32_t conversation_count;
-} chat_stats_t;
-
-/* Chat服务上下文 */
-typedef struct {
- ai_service_context_t base; // 基础服务上下文
-
- /* Chat特定配置 */
- chat_model_config_t model_config;
- chat_response_mode_t response_mode;
-
- /* 会话管理 */
- chat_conversation_t *conversations;
- size_t conversation_count;
- size_t max_conversations;
- char current_session_id[64];
- osMutexId_t conversation_mutex;
-
- /* TTS接口回调 */
- ai_service_error_t (*tts_send_text)(const char *text, const char *session_id);
-
- /* 回调函数 */
- void (*on_chat_start)(void *context, const char *session_id);
- void (*on_chat_response)(void *context, const chat_response_t *response);
- void (*on_chat_complete)(void *context, const char *session_id);
- void (*on_chat_streaming)(void *context, const char *session_id, const char *partial_content);
-
- /* 统计信息 */
- chat_stats_t chat_stats;
-} chat_server_context_t;
-
-/* Chat服务接口函数 */
-
-/**
- * @brief 初始化Chat服务
- * @param context Chat服务上下文
- * @param server_url 服务器URL
- * @param model_config 模型配置
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t chat_server_init(chat_server_context_t *context,
- const char *server_url,
- const chat_model_config_t *model_config);
-
-/**
- * @brief 销毁Chat服务
- * @param context Chat服务上下文
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t chat_server_destroy(chat_server_context_t *context);
-
-/**
- * @brief 启动Chat服务
- * @param context Chat服务上下文
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t chat_server_start(chat_server_context_t *context);
-
-/**
- * @brief 停止Chat服务
- * @param context Chat服务上下文
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t chat_server_stop(chat_server_context_t *context);
-
-/**
- * @brief 发送聊天消息
- * @param context Chat服务上下文
- * @param message 消息内容
- * @param session_id 会话ID（可选，为NULL时自动生成）
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t chat_server_send_message(chat_server_context_t *context,
- const char *message,
- const char *session_id);
-
-/**
- * @brief 发送聊天请求
- * @param context Chat服务上下文
- * @param request 聊天请求
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t chat_server_send_request(chat_server_context_t *context,
- const chat_request_t *request);
-
-/**
- * @brief 创建新会话
- * @param context Chat服务上下文
- * @param session_id 会话ID（可选，为NULL时自动生成）
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t chat_server_create_session(chat_server_context_t *context,
- const char *session_id);
-
-/**
- * @brief 删除会话
- * @param context Chat服务上下文
- * @param session_id 会话ID
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t chat_server_delete_session(chat_server_context_t *context,
- const char *session_id);
-
-/**
- * @brief 清空会话历史
- * @param context Chat服务上下文
- * @param session_id 会话ID
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t chat_server_clear_session_history(chat_server_context_t *context,
- const char *session_id);
-
-/**
- * @brief 获取会话历史
- * @param context Chat服务上下文
- * @param session_id 会话ID
- * @return 会话历史指针，NULL表示会话不存在
- */
-const chat_conversation_t* chat_server_get_session_history(chat_server_context_t *context,
- const char *session_id);
-
-/**
- * @brief 设置模型配置
- * @param context Chat服务上下文
- * @param model_config 模型配置
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t chat_server_set_model_config(chat_server_context_t *context,
- const chat_model_config_t *model_config);
-
-/**
- * @brief 设置响应模式
- * @param context Chat服务上下文
- * @param response_mode 响应模式
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t chat_server_set_response_mode(chat_server_context_t *context,
- chat_response_mode_t response_mode);
-
-/**
- * @brief 设置TTS接口回调
- * @param context Chat服务上下文
- * @param tts_send_text TTS发送文本接口
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t chat_server_set_tts_interface(chat_server_context_t *context,
- ai_service_error_t (*tts_send_text)(const char *text, const char *session_id));
-
-/**
- * @brief 获取当前会话ID
- * @param context Chat服务上下文
- * @return 会话ID字符串，NULL表示无活动会话
- */
-const char* chat_server_get_current_session_id(chat_server_context_t *context);
-
-/**
- * @brief 获取会话数量
- * @param context Chat服务上下文
- * @return 会话数量
- */
-size_t chat_server_get_session_count(chat_server_context_t *context);
-
-/**
- * @brief 设置Chat回调函数
- * @param context Chat服务上下文
- * @param on_chat_start 聊天开始回调
- * @param on_chat_response 聊天响应回调
- * @param on_chat_complete 聊天完成回调
- * @param on_chat_streaming 流式响应回调
- */
-void chat_server_set_callbacks(chat_server_context_t *context,
- void (*on_chat_start)(void *context, const char *session_id),
- void (*on_chat_response)(void *context, const chat_response_t *response),
- void (*on_chat_complete)(void *context, const char *session_id),
- void (*on_chat_streaming)(void *context, const char *session_id, const char *partial_content));
-
-/**
- * @brief 获取Chat统计信息
- * @param context Chat服务上下文
- * @return 统计信息指针
- */
-const chat_stats_t* chat_server_get_stats(chat_server_context_t *context);
-
-/* 会话管理函数 */
-
-/**
- * @brief 添加消息到会话历史
- * @param conversation 会话对象
- * @param role 消息角色
- * @param content 消息内容
- * @param message_type 消息类型
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t chat_conversation_add_message(chat_conversation_t *conversation,
- chat_role_t role,
- const char *content,
- chat_message_type_t message_type);
-
-/**
- * @brief 获取会话最后一条消息
- * @param conversation 会话对象
- * @return 消息指针，NULL表示无消息
- */
-const chat_message_t* chat_conversation_get_last_message(const chat_conversation_t *conversation);
-
-/**
- * @brief 清空会话消息
- * @param conversation 会话对象
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t chat_conversation_clear_messages(chat_conversation_t *conversation);
-
-/**
- * @brief 释放会话内存
- * @param conversation 会话对象
- */
-void chat_conversation_free(chat_conversation_t *conversation);
-
-/* 工具函数 */
-
-/**
- * @brief 创建默认模型配置
- * @param config 输出配置
- */
-void chat_server_create_default_model_config(chat_model_config_t *config);
-
-/**
- * @brief 释放聊天响应内存
- * @param response 聊天响应
- */
-void chat_server_free_response(chat_response_t *response);
-
-/**
- * @brief 释放聊天消息内存
- * @param message 聊天消息
- */
-void chat_server_free_message(chat_message_t *message);
-
-/**
- * @brief 消息类型转字符串
- * @param message_type 消息类型
- * @return 类型字符串
- */
-const char* chat_server_message_type_to_string(chat_message_type_t message_type);
-
-/**
- * @brief 角色转字符串
- * @param role 角色
- * @return 角色字符串
- */
-const char* chat_server_role_to_string(chat_role_t role);
-
-/**
- * @brief 模型类型转字符串
- * @param model_type 模型类型
- * @return 类型字符串
- */
-const char* chat_server_model_type_to_string(chat_model_type_t model_type);
-
-/**
- * @brief 响应模式转字符串
- * @param response_mode 响应模式
- * @return 模式字符串
- */
-const char* chat_server_response_mode_to_string(chat_response_mode_t response_mode);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* CHAT_SERVER_H */
\ No newline at end of file
+++ /dev/null
-/*
- * TTS (Text-to-Speech) 服务头文件
- * 负责建立与TTS服务器的WebSocket连接管理，上传文本，接收音频流并播放
- */
-
-#ifndef TTS_SERVER_H
-#define TTS_SERVER_H
-
-#include "ai_service_common.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* TTS特定配置 */
-#define TTS_MAX_TEXT_LENGTH 2048
-#define TTS_MAX_AUDIO_BUFFER_SIZE 16384
-#define TTS_MAX_VOICE_NAME_LENGTH 64
-#define TTS_MAX_SSML_LENGTH 4096
-
-/* TTS音频格式枚举 */
-typedef enum {
- TTS_AUDIO_FORMAT_PCM = 0,
- TTS_AUDIO_FORMAT_WAV,
- TTS_AUDIO_FORMAT_MP3,
- TTS_AUDIO_FORMAT_AAC,
- TTS_AUDIO_FORMAT_OGG
-} tts_audio_format_t;
-
-/* TTS语音类型枚举 */
-typedef enum {
- TTS_VOICE_TYPE_MALE = 0,
- TTS_VOICE_TYPE_FEMALE,
- TTS_VOICE_TYPE_CHILD,
- TTS_VOICE_TYPE_ELDERLY
-} tts_voice_type_t;
-
-/* TTS语言枚举 */
-typedef enum {
- TTS_LANGUAGE_ZH_CN = 0, // 中文
- TTS_LANGUAGE_EN_US, // 英文
- TTS_LANGUAGE_JA_JP, // 日文
- TTS_LANGUAGE_KO_KR // 韩文
-} tts_language_t;
-
-/* TTS情感枚举 */
-typedef enum {
- TTS_EMOTION_NEUTRAL = 0, // 中性
- TTS_EMOTION_HAPPY, // 高兴
- TTS_EMOTION_SAD, // 悲伤
- TTS_EMOTION_ANGRY, // 愤怒
- TTS_EMOTION_EXCITED, // 兴奋
- TTS_EMOTION_CALM // 平静
-} tts_emotion_t;
-
-/* TTS音频配置 */
-typedef struct {
- tts_audio_format_t format;
- uint32_t sample_rate;
- uint8_t channels;
- uint8_t bits_per_sample;
- uint32_t bitrate;
-} tts_audio_config_t;
-
-/* TTS语音配置 */
-typedef struct {
- char voice_name[TTS_MAX_VOICE_NAME_LENGTH];
- tts_voice_type_t voice_type;
- tts_language_t language;
- tts_emotion_t emotion;
- float speed; // 语速 (0.5-2.0)
- float pitch; // 音调 (0.5-2.0)
- float volume; // 音量 (0.0-1.0)
-} tts_voice_config_t;
-
-/* TTS合成请求 */
-typedef struct {
- char *text; // 文本内容
- char *ssml; // SSML内容（可选）
- char session_id[64]; // 会话ID
- tts_voice_config_t voice_config;
- bool use_ssml; // 是否使用SSML
-} tts_synthesis_request_t;
-
-/* TTS合成结果 */
-typedef struct {
- char *audio_data; // 音频数据
- size_t audio_length; // 音频长度
- tts_audio_config_t audio_config;
- char session_id[64]; // 会话ID
- bool is_final; // 是否为最终数据
- uint32_t sequence_number; // 序列号
-} tts_synthesis_result_t;
-
-/* TTS播放状态枚举 */
-typedef enum {
- TTS_PLAYBACK_STATE_IDLE = 0,
- TTS_PLAYBACK_STATE_PLAYING,
- TTS_PLAYBACK_STATE_PAUSED,
- TTS_PLAYBACK_STATE_STOPPED,
- TTS_PLAYBACK_STATE_ERROR
-} tts_playback_state_t;
-
-/* TTS服务上下文 */
-typedef struct {
- ai_service_context_t base; // 基础服务上下文
-
- /* TTS特定配置 */
- tts_audio_config_t audio_config;
- tts_voice_config_t voice_config;
-
- /* 音频缓冲区 */
- char *audio_buffer;
- size_t audio_buffer_size;
- size_t audio_buffer_used;
- osMutexId_t audio_buffer_mutex;
-
- /* 播放管理 */
- tts_playback_state_t playback_state;
- osThreadId_t playback_thread;
- osSemaphoreId_t playback_sem;
-
- /* 会话管理 */
- char current_session_id[64];
- bool synthesis_active;
- uint32_t current_sequence;
-
- /* 回调函数 */
- void (*on_synthesis_start)(void *context, const char *session_id);
- void (*on_synthesis_result)(void *context, const tts_synthesis_result_t *result);
- void (*on_synthesis_complete)(void *context, const char *session_id);
- void (*on_playback_start)(void *context);
- void (*on_playback_complete)(void *context);
- void (*on_playback_error)(void *context, int error_code);
-
- /* 统计信息 */
- uint32_t total_text_sent;
- uint32_t total_audio_received;
- uint32_t synthesis_sessions;
- uint32_t playback_sessions;
-} tts_server_context_t;
-
-/* TTS服务接口函数 */
-
-/**
- * @brief 初始化TTS服务
- * @param context TTS服务上下文
- * @param server_url 服务器URL
- * @param audio_config 音频配置
- * @param voice_config 语音配置
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t tts_server_init(tts_server_context_t *context,
- const char *server_url,
- const tts_audio_config_t *audio_config,
- const tts_voice_config_t *voice_config);
-
-/**
- * @brief 销毁TTS服务
- * @param context TTS服务上下文
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t tts_server_destroy(tts_server_context_t *context);
-
-/**
- * @brief 启动TTS服务
- * @param context TTS服务上下文
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t tts_server_start(tts_server_context_t *context);
-
-/**
- * @brief 停止TTS服务
- * @param context TTS服务上下文
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t tts_server_stop(tts_server_context_t *context);
-
-/**
- * @brief 合成语音（文本）
- * @param context TTS服务上下文
- * @param text 文本内容
- * @param session_id 会话ID（可选，为NULL时自动生成）
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t tts_server_synthesize_text(tts_server_context_t *context,
- const char *text,
- const char *session_id);
-
-/**
- * @brief 合成语音（SSML）
- * @param context TTS服务上下文
- * @param ssml SSML内容
- * @param session_id 会话ID（可选，为NULL时自动生成）
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t tts_server_synthesize_ssml(tts_server_context_t *context,
- const char *ssml,
- const char *session_id);
-
-/**
- * @brief 合成语音（请求结构）
- * @param context TTS服务上下文
- * @param request 合成请求
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t tts_server_synthesize_request(tts_server_context_t *context,
- const tts_synthesis_request_t *request);
-
-/**
- * @brief 停止当前合成
- * @param context TTS服务上下文
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t tts_server_stop_synthesis(tts_server_context_t *context);
-
-/**
- * @brief 开始播放音频
- * @param context TTS服务上下文
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t tts_server_start_playback(tts_server_context_t *context);
-
-/**
- * @brief 暂停播放音频
- * @param context TTS服务上下文
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t tts_server_pause_playback(tts_server_context_t *context);
-
-/**
- * @brief 恢复播放音频
- * @param context TTS服务上下文
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t tts_server_resume_playback(tts_server_context_t *context);
-
-/**
- * @brief 停止播放音频
- * @param context TTS服务上下文
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t tts_server_stop_playback(tts_server_context_t *context);
-
-/**
- * @brief 设置音频配置
- * @param context TTS服务上下文
- * @param audio_config 音频配置
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t tts_server_set_audio_config(tts_server_context_t *context,
- const tts_audio_config_t *audio_config);
-
-/**
- * @brief 设置语音配置
- * @param context TTS服务上下文
- * @param voice_config 语音配置
- * @return AI_SERVICE_OK 成功，其他值失败
- */
-ai_service_error_t tts_server_set_voice_config(tts_server_context_t *context,
- const tts_voice_config_t *voice_config);
-
-/**
- * @brief 获取当前会话ID
- * @param context TTS服务上下文
- * @return 会话ID字符串，NULL表示无活动会话
- */
-const char* tts_server_get_current_session_id(tts_server_context_t *context);
-
-/**
- * @brief 检查是否有活动的合成会话
- * @param context TTS服务上下文
- * @return true 有活动会话，false 无活动会话
- */
-bool tts_server_is_synthesis_active(tts_server_context_t *context);
-
-/**
- * @brief 获取播放状态
- * @param context TTS服务上下文
- * @return 播放状态
- */
-tts_playback_state_t tts_server_get_playback_state(tts_server_context_t *context);
-
-/**
- * @brief 设置TTS回调函数
- * @param context TTS服务上下文
- * @param on_synthesis_start 合成开始回调
- * @param on_synthesis_result 合成结果回调
- * @param on_synthesis_complete 合成完成回调
- * @param on_playback_start 播放开始回调
- * @param on_playback_complete 播放完成回调
- * @param on_playback_error 播放错误回调
- */
-void tts_server_set_callbacks(tts_server_context_t *context,
- void (*on_synthesis_start)(void *context, const char *session_id),
- void (*on_synthesis_result)(void *context, const tts_synthesis_result_t *result),
- void (*on_synthesis_complete)(void *context, const char *session_id),
- void (*on_playback_start)(void *context),
- void (*on_playback_complete)(void *context),
- void (*on_playback_error)(void *context, int error_code));
-
-/**
- * @brief 获取TTS统计信息
- * @param context TTS服务上下文
- * @param total_text_sent 总发送文本字符数
- * @param total_audio_received 总接收音频字节数
- * @param synthesis_sessions 合成会话数
- * @param playback_sessions 播放会话数
- */
-void tts_server_get_stats(tts_server_context_t *context,
- uint32_t *total_text_sent,
- uint32_t *total_audio_received,
- uint32_t *synthesis_sessions,
- uint32_t *playback_sessions);
-
-/* 工具函数 */
-
-/**
- * @brief 创建默认音频配置
- * @param config 输出配置
- */
-void tts_server_create_default_audio_config(tts_audio_config_t *config);
-
-/**
- * @brief 创建默认语音配置
- * @param config 输出配置
- */
-void tts_server_create_default_voice_config(tts_voice_config_t *config);
-
-/**
- * @brief 释放合成结果内存
- * @param result 合成结果
- */
-void tts_server_free_synthesis_result(tts_synthesis_result_t *result);
-
-/**
- * @brief 音频格式转字符串
- * @param format 音频格式
- * @return 格式字符串
- */
-const char* tts_server_audio_format_to_string(tts_audio_format_t format);
-
-/**
- * @brief 语音类型转字符串
- * @param voice_type 语音类型
- * @return 类型字符串
- */
-const char* tts_server_voice_type_to_string(tts_voice_type_t voice_type);
-
-/**
- * @brief 语言转字符串
- * @param language 语言
- * @return 语言字符串
- */
-const char* tts_server_language_to_string(tts_language_t language);
-
-/**
- * @brief 情感转字符串
- * @param emotion 情感
- * @return 情感字符串
- */
-const char* tts_server_emotion_to_string(tts_emotion_t emotion);
-
-/**
- * @brief 播放状态转字符串
- * @param state 播放状态
- * @return 状态字符串
- */
-const char* tts_server_playback_state_to_string(tts_playback_state_t state);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* TTS_SERVER_H */
\ No newline at end of file
--- /dev/null
+/**
+ * @file ai_connection_manager.c
+ * @brief AI多连接管理器实现 - LiteOS-M优化版v2
+ * @version 2.0
+ * @date 2024-01-20
+ */
+
+#include "ai_connection_manager.h"
+#include "ai_memory_pool.h"
+#include <string.h>
+#include <stdio.h>
+
+#ifdef __TEST_MODE__
+#include <unistd.h> // for usleep in test mode
+#endif
+
+#ifndef __TEST_MODE__
+#include "wearable_log.h"
+#include "dev_authentication.h"
+#define AI_LOG_TAG "AI_CONN_MGR"
+#define AI_LOGI(fmt, ...) WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] " fmt, AI_LOG_TAG, ##__VA_ARGS__)
+#define AI_LOGE(fmt, ...) WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] " fmt, AI_LOG_TAG, ##__VA_ARGS__)
+#define AI_LOGW(fmt, ...) WEARABLE_LOGW(WEARABLE_LOG_MODULE_APP, "[%s] " fmt, AI_LOG_TAG, ##__VA_ARGS__)
+#else
+#define AI_LOGI(fmt, ...) printf("[AI_CONN_MGR] " fmt "\n", ##__VA_ARGS__)
+#define AI_LOGE(fmt, ...) printf("[AI_CONN_MGR] ERROR: " fmt "\n", ##__VA_ARGS__)
+#define AI_LOGW(fmt, ...) printf("[AI_CONN_MGR] WARN: " fmt "\n", ##__VA_ARGS__)
+#endif
+
+/* ================================ 全局变量 ================================ */
+
+static ai_connection_manager_t g_connection_manager = {0};
+static bool g_manager_initialized = false;
+
+/* 服务名称映射表 */
+static const char* g_service_names[AI_SERVICE_COUNT] = {
+ "ASR", "Chat", "TTS"
+};
+
+/* 状态名称映射表 */
+static const char* g_state_names[] = {
+ "UNINITIALIZED", "INITIALIZING", "CONNECTING",
+ "READY", "PARTIAL", "DEGRADED", "ERROR"
+};
+
+/* ================================ 内部函数声明 ================================ */
+
+static ai_error_t connection_thread_create(ai_service_type_t service_type);
+static void connection_thread_entry(void *argument);
+static void worker_thread_entry(void *argument);
+static ai_error_t websocket_connect(ai_connection_info_t *conn_info);
+static void websocket_on_connected(int client);
+static void websocket_on_message(int client, const char *data, size_t length, bool isFinished);
+static void websocket_on_error(int client, struct WebSocketErrorResult errorResult);
+static void websocket_on_disconnected(int client);
+static ai_error_t update_global_state(void);
+static void send_event(ai_event_type_t type, ai_service_type_t service, const void *data);
+static uint32_t get_current_timestamp(void);
+/* static ai_error_t build_service_url(ai_service_type_t service_type, char *url_buffer, size_t buffer_size); */
+
+#ifndef __TEST_MODE__
+static void heartbeat_timer_callback(void *argument);
+#endif
+
+/* ================================ 公共接口实现 ================================ */
+
+ai_error_t ai_connection_manager_init(const ai_connection_manager_config_t *config)
+{
+ if (config == NULL) {
+ AI_LOGE("Invalid config parameter");
+ return AI_ERROR_INVALID_PARAM;
+ }
+
+ if (g_manager_initialized) {
+ AI_LOGW("Connection manager already initialized");
+ return AI_ERROR_ALREADY_INITIALIZED;
+ }
+
+ AI_LOGI("Initializing connection manager...");
+
+ /* 清空管理器结构 */
+ memset(&g_connection_manager, 0, sizeof(g_connection_manager));
+
+ /* 复制配置 */
+ memcpy(&g_connection_manager.config, config, sizeof(ai_connection_manager_config_t));
+
+ /* 初始化状态 */
+ g_connection_manager.global_state = AI_STATE_INITIALIZING;
+ g_connection_manager.init_timestamp = get_current_timestamp();
+
+#ifndef __TEST_MODE__
+ /* 创建全局互斥锁 */
+ g_connection_manager.global_mutex = osMutexNew(NULL);
+ if (g_connection_manager.global_mutex == NULL) {
+ AI_LOGE("Failed to create global mutex");
+ return AI_ERROR_MEMORY_ALLOC;
+ }
+
+ /* 创建事件队列 */
+ g_connection_manager.event_queue = osMessageQueueNew(16, sizeof(ai_event_t), NULL);
+ if (g_connection_manager.event_queue == NULL) {
+ AI_LOGE("Failed to create event queue");
+ osMutexDelete(g_connection_manager.global_mutex);
+ return AI_ERROR_MEMORY_ALLOC;
+ }
+
+ /* 创建心跳定时器 */
+ if (config->keepalive_interval_ms > 0) {
+ g_connection_manager.heartbeat_timer = osTimerNew(heartbeat_timer_callback,
+ osTimerPeriodic, NULL, NULL);
+ if (g_connection_manager.heartbeat_timer == NULL) {
+ AI_LOGW("Failed to create heartbeat timer");
+ }
+ }
+#endif
+
+ /* 初始化连接信息 */
+ for (int i = 0; i < AI_SERVICE_COUNT; i++) {
+ ai_connection_info_t *conn = &g_connection_manager.connections[i];
+ conn->service_type = (ai_service_type_t)i;
+ conn->state = AI_CONN_STATE_DISCONNECTED;
+
+ /* 设置服务URL */
+ switch (i) {
+ case AI_SERVICE_ASR:
+ strncpy(conn->url, config->connection_config.asr_url, AI_MAX_URL_LENGTH - 1);
+ break;
+ case AI_SERVICE_CHAT:
+ strncpy(conn->url, config->connection_config.chat_url, AI_MAX_URL_LENGTH - 1);
+ break;
+ case AI_SERVICE_TTS:
+ strncpy(conn->url, config->connection_config.tts_url, AI_MAX_URL_LENGTH - 1);
+ break;
+ }
+
+#ifndef __TEST_MODE__
+ /* 创建连接互斥锁 */
+ conn->mutex = osMutexNew(NULL);
+ if (conn->mutex == NULL) {
+ AI_LOGE("Failed to create connection mutex for service %d", i);
+ /* 清理已创建的资源 */
+ for (int j = 0; j < i; j++) {
+ osMutexDelete(g_connection_manager.connections[j].mutex);
+ }
+ osMutexDelete(g_connection_manager.global_mutex);
+ osMessageQueueDelete(g_connection_manager.event_queue);
+ return AI_ERROR_MEMORY_ALLOC;
+ }
+
+ /* 创建就绪信号量 */
+ conn->ready_semaphore = osSemaphoreNew(1, 0, NULL);
+ if (conn->ready_semaphore == NULL) {
+ AI_LOGE("Failed to create ready semaphore for service %d", i);
+ /* 清理资源 */
+ osMutexDelete(conn->mutex);
+ for (int j = 0; j < i; j++) {
+ osMutexDelete(g_connection_manager.connections[j].mutex);
+ osSemaphoreDelete(g_connection_manager.connections[j].ready_semaphore);
+ }
+ osMutexDelete(g_connection_manager.global_mutex);
+ osMessageQueueDelete(g_connection_manager.event_queue);
+ return AI_ERROR_MEMORY_ALLOC;
+ }
+#endif
+
+ /* 分配缓冲区 */
+ conn->send_buffer = ai_memory_pool_alloc_connection((ai_service_type_t)i);
+ conn->recv_buffer = ai_memory_pool_alloc_connection((ai_service_type_t)i);
+
+ if (conn->send_buffer == NULL || conn->recv_buffer == NULL) {
+ AI_LOGE("Failed to allocate buffers for service %d", i);
+ return AI_ERROR_MEMORY_ALLOC;
+ }
+ }
+
+#ifndef __TEST_MODE__
+ /* 创建工作线程 */
+ osThreadAttr_t worker_attr = {
+ .name = "ai_worker",
+ .stack_size = AI_WORKER_STACK_SIZE,
+ .priority = config->worker_thread_priority
+ };
+
+ g_connection_manager.worker_thread_id = osThreadNew(worker_thread_entry, NULL, &worker_attr);
+ if (g_connection_manager.worker_thread_id == NULL) {
+ AI_LOGE("Failed to create worker thread");
+ return AI_ERROR_MEMORY_ALLOC;
+ }
+#endif
+
+ g_connection_manager.is_initialized = true;
+ g_manager_initialized = true;
+
+ AI_LOGI("Connection manager initialized successfully");
+ return AI_OK;
+}
+
+ai_error_t ai_connection_manager_destroy(void)
+{
+ if (!g_manager_initialized) {
+ return AI_ERROR_NOT_INITIALIZED;
+ }
+
+ AI_LOGI("Destroying connection manager...");
+
+ /* 停止所有连接 */
+ ai_connection_manager_stop_all();
+
+ /* 等待工作线程退出 */
+ g_connection_manager.is_running = false;
+
+#ifndef __TEST_MODE__
+ if (g_connection_manager.worker_thread_id != NULL) {
+ osThreadTerminate(g_connection_manager.worker_thread_id);
+ g_connection_manager.worker_thread_id = NULL;
+ }
+
+ /* 停止心跳定时器 */
+ if (g_connection_manager.heartbeat_timer != NULL) {
+ osTimerStop(g_connection_manager.heartbeat_timer);
+ osTimerDelete(g_connection_manager.heartbeat_timer);
+ g_connection_manager.heartbeat_timer = NULL;
+ }
+#endif
+
+ /* 清理连接资源 */
+ for (int i = 0; i < AI_SERVICE_COUNT; i++) {
+ ai_connection_info_t *conn = &g_connection_manager.connections[i];
+
+ /* 释放缓冲区 */
+ if (conn->send_buffer != NULL) {
+ ai_memory_pool_free(conn->send_buffer);
+ conn->send_buffer = NULL;
+ }
+ if (conn->recv_buffer != NULL) {
+ ai_memory_pool_free(conn->recv_buffer);
+ conn->recv_buffer = NULL;
+ }
+
+#ifndef __TEST_MODE__
+ /* 删除同步对象 */
+ if (conn->mutex != NULL) {
+ osMutexDelete(conn->mutex);
+ conn->mutex = NULL;
+ }
+ if (conn->ready_semaphore != NULL) {
+ osSemaphoreDelete(conn->ready_semaphore);
+ conn->ready_semaphore = NULL;
+ }
+
+ /* 终止连接线程 */
+ if (conn->thread_id != NULL) {
+ osThreadTerminate(conn->thread_id);
+ conn->thread_id = NULL;
+ }
+#endif
+
+ /* 关闭WebSocket连接 */
+ if (conn->websocket >= 0) {
+#ifndef __TEST_MODE__
+ WebSocketClientClose(conn->websocket);
+#endif
+ conn->websocket = -1;
+ }
+ }
+
+#ifndef __TEST_MODE__
+ /* 删除全局资源 */
+ if (g_connection_manager.global_mutex != NULL) {
+ osMutexDelete(g_connection_manager.global_mutex);
+ g_connection_manager.global_mutex = NULL;
+ }
+ if (g_connection_manager.event_queue != NULL) {
+ osMessageQueueDelete(g_connection_manager.event_queue);
+ g_connection_manager.event_queue = NULL;
+ }
+#endif
+
+ /* 重置状态 */
+ memset(&g_connection_manager, 0, sizeof(g_connection_manager));
+ g_manager_initialized = false;
+
+ AI_LOGI("Connection manager destroyed");
+ return AI_OK;
+}
+
+ai_error_t ai_connection_manager_start_all(void)
+{
+ if (!g_manager_initialized) {
+ return AI_ERROR_NOT_INITIALIZED;
+ }
+
+ AI_LOGI("Starting all connections concurrently...");
+
+ g_connection_manager.global_state = AI_STATE_CONNECTING;
+ g_connection_manager.is_running = true;
+
+ /* 记录连接开始时间 */
+ uint32_t start_time = get_current_timestamp();
+ g_connection_manager.metrics.last_connect_timestamp = start_time;
+
+ /* 并发启动所有连接线程 */
+ for (int i = 0; i < AI_SERVICE_COUNT; i++) {
+ ai_error_t ret = connection_thread_create((ai_service_type_t)i);
+ if (ret != AI_OK) {
+ AI_LOGE("Failed to create connection thread for service %s", g_service_names[i]);
+ return ret;
+ }
+ }
+
+#ifndef __TEST_MODE__
+ /* 启动心跳定时器 */
+ if (g_connection_manager.heartbeat_timer != NULL) {
+ osTimerStart(g_connection_manager.heartbeat_timer,
+ g_connection_manager.config.keepalive_interval_ms);
+ }
+#endif
+
+ AI_LOGI("All connection threads started");
+ return AI_OK;
+}
+
+ai_error_t ai_connection_manager_stop_all(void)
+{
+ if (!g_manager_initialized) {
+ return AI_ERROR_NOT_INITIALIZED;
+ }
+
+ AI_LOGI("Stopping all connections...");
+
+ g_connection_manager.is_running = false;
+
+ /* 停止所有连接 */
+ for (int i = 0; i < AI_SERVICE_COUNT; i++) {
+ ai_connection_info_t *conn = &g_connection_manager.connections[i];
+
+#ifndef __TEST_MODE__
+ if (conn->mutex != NULL) {
+ osMutexAcquire(conn->mutex, osWaitForever);
+ }
+#endif
+
+ if (conn->websocket >= 0) {
+#ifndef __TEST_MODE__
+ WebSocketClientClose(conn->websocket);
+#endif
+ }
+ conn->state = AI_CONN_STATE_DISCONNECTED;
+
+#ifndef __TEST_MODE__
+ if (conn->mutex != NULL) {
+ osMutexRelease(conn->mutex);
+ }
+#endif
+ }
+
+ /* 更新连接状态矩阵 */
+ g_connection_manager.connection_matrix.asr_connected = 0;
+ g_connection_manager.connection_matrix.chat_connected = 0;
+ g_connection_manager.connection_matrix.tts_connected = 0;
+
+ update_global_state();
+
+ AI_LOGI("All connections stopped");
+ return AI_OK;
+}
+
+ai_error_t ai_connection_manager_send_data(ai_service_type_t service_type,
+ const char *data, size_t length)
+{
+ if (!g_manager_initialized) {
+ return AI_ERROR_NOT_INITIALIZED;
+ }
+
+ if (service_type >= AI_SERVICE_COUNT || data == NULL || length == 0) {
+ return AI_ERROR_INVALID_PARAM;
+ }
+
+ ai_connection_info_t *conn = &g_connection_manager.connections[service_type];
+
+#ifndef __TEST_MODE__
+ if (conn->mutex != NULL) {
+ osMutexAcquire(conn->mutex, osWaitForever);
+ }
+#endif
+
+ ai_error_t result = AI_OK;
+
+ if (conn->state != AI_CONN_STATE_CONNECTED || conn->websocket < 0) {
+ AI_LOGW("Service %s not connected, cannot send data", g_service_names[service_type]);
+ result = AI_ERROR_SERVICE_UNAVAILABLE;
+ } else {
+ /* 检查缓冲区空间 */
+ if (conn->send_buffer != NULL && length <= conn->send_buffer->size) {
+ memcpy(conn->send_buffer->buffer, data, length);
+ conn->send_buffer->used = length;
+
+#ifndef __TEST_MODE__
+ /* 发送数据 */
+ int ret = WebSocketClientSendText(conn->websocket, (const char*)conn->send_buffer->buffer, length);
+ if (ret < 0) {
+ AI_LOGE("Failed to send data to service %s", g_service_names[service_type]);
+ result = AI_ERROR_WEBSOCKET;
+ } else {
+ /* 更新统计 */
+ g_connection_manager.metrics.total_bytes_sent += length;
+ conn->last_activity_time = get_current_timestamp();
+ }
+#else
+ AI_LOGI("TEST: Sending %zu bytes to service %s", length, g_service_names[service_type]);
+ g_connection_manager.metrics.total_bytes_sent += length;
+#endif
+ } else {
+ AI_LOGE("Send buffer too small for service %s", g_service_names[service_type]);
+ result = AI_ERROR_BUFFER_OVERFLOW;
+ }
+ }
+
+#ifndef __TEST_MODE__
+ if (conn->mutex != NULL) {
+ osMutexRelease(conn->mutex);
+ }
+#endif
+
+ return result;
+}
+
+ai_global_state_t ai_connection_manager_get_state(void)
+{
+ if (!g_manager_initialized) {
+ return AI_STATE_UNINITIALIZED;
+ }
+
+ return g_connection_manager.global_state;
+}
+
+ai_connection_matrix_t ai_connection_manager_get_matrix(void)
+{
+ ai_connection_matrix_t matrix = {0};
+
+ if (!g_manager_initialized) {
+ return matrix;
+ }
+
+ return g_connection_manager.connection_matrix;
+}
+
+ai_connection_state_t ai_connection_manager_get_connection_state(ai_service_type_t service_type)
+{
+ if (!g_manager_initialized || service_type >= AI_SERVICE_COUNT) {
+ return AI_CONN_STATE_DISCONNECTED;
+ }
+
+ return g_connection_manager.connections[service_type].state;
+}
+
+const ai_connect_metrics_t* ai_connection_manager_get_metrics(void)
+{
+ if (!g_manager_initialized) {
+ return NULL;
+ }
+
+ return &g_connection_manager.metrics;
+}
+
+ai_error_t ai_connection_manager_wait_ready(ai_service_type_t service_type, uint32_t timeout_ms)
+{
+ if (!g_manager_initialized || service_type >= AI_SERVICE_COUNT) {
+ return AI_ERROR_INVALID_PARAM;
+ }
+
+ ai_connection_info_t *conn = &g_connection_manager.connections[service_type];
+
+ if (conn->state == AI_CONN_STATE_CONNECTED) {
+ return AI_OK;
+ }
+
+#ifndef __TEST_MODE__
+ /* 等待就绪信号量 */
+ osStatus_t status = osSemaphoreAcquire(conn->ready_semaphore, timeout_ms);
+ if (status == osOK) {
+ return AI_OK;
+ } else if (status == osErrorTimeout) {
+ return AI_ERROR_TIMEOUT;
+ } else {
+ return AI_ERROR_NETWORK;
+ }
+#else
+ AI_LOGI("TEST: Waiting for service %s ready (timeout: %u ms)",
+ g_service_names[service_type], timeout_ms);
+ return AI_OK;
+#endif
+}
+
+ai_error_t ai_connection_manager_wait_all_ready(uint32_t timeout_ms)
+{
+ if (!g_manager_initialized) {
+ return AI_ERROR_NOT_INITIALIZED;
+ }
+
+ uint32_t start_time = get_current_timestamp();
+
+ for (int i = 0; i < AI_SERVICE_COUNT; i++) {
+ uint32_t elapsed = get_current_timestamp() - start_time;
+ if (elapsed >= timeout_ms) {
+ return AI_ERROR_TIMEOUT;
+ }
+
+ uint32_t remaining = timeout_ms - elapsed;
+ ai_error_t ret = ai_connection_manager_wait_ready((ai_service_type_t)i, remaining);
+ if (ret != AI_OK) {
+ return ret;
+ }
+ }
+
+ return AI_OK;
+}
+
+/* ================================ 配置辅助函数实现 ================================ */
+
+void ai_connection_manager_create_default_config(ai_connection_manager_config_t *config)
+{
+ if (config == NULL) {
+ return;
+ }
+
+ memset(config, 0, sizeof(ai_connection_manager_config_t));
+
+ /* 连接配置 */
+ config->connection_config.connect_timeout_ms = AI_CONNECT_TIMEOUT_MS;
+ config->connection_config.concurrent_connect = 1;
+ config->connection_config.backup_connections = 0;
+ config->connection_config.strategy = AI_CONNECT_STRATEGY_CONCURRENT;
+
+ /* 音频配置 */
+ config->audio_config.sample_rate = 16000;
+ config->audio_config.channels = 1;
+ config->audio_config.bits_per_sample = 16;
+ config->audio_config.format = AI_AUDIO_FORMAT_PCM;
+
+ /* 线程配置 */
+#ifndef __TEST_MODE__
+ config->connection_thread_priority = osPriorityNormal;
+ config->worker_thread_priority = osPriorityNormal;
+#else
+ config->connection_thread_priority = 5; // 模拟优先级
+ config->worker_thread_priority = 5; // 模拟优先级
+#endif
+
+ /* 重连配置 */
+ config->max_retry_count = 3;
+ config->retry_interval_ms = 5000;
+ config->auto_reconnect = true;
+
+ /* 性能配置 */
+ config->enable_connection_cache = false;
+ config->enable_metrics = true;
+ config->keepalive_interval_ms = AI_HEARTBEAT_INTERVAL_MS;
+}
+
+const char* ai_connection_manager_get_service_name(ai_service_type_t service_type)
+{
+ if (service_type >= AI_SERVICE_COUNT) {
+ return "UNKNOWN";
+ }
+
+ return g_service_names[service_type];
+}
+
+const char* ai_connection_manager_get_state_name(ai_global_state_t state)
+{
+ if (state >= sizeof(g_state_names) / sizeof(g_state_names[0])) {
+ return "UNKNOWN";
+ }
+
+ return g_state_names[state];
+}
+
+/* ================================ 内部函数实现 ================================ */
+
+static ai_error_t connection_thread_create(ai_service_type_t service_type)
+{
+ if (service_type >= AI_SERVICE_COUNT) {
+ return AI_ERROR_INVALID_PARAM;
+ }
+
+ ai_connection_info_t *conn = &g_connection_manager.connections[service_type];
+
+#ifndef __TEST_MODE__
+ osThreadAttr_t thread_attr = {
+ .stack_size = AI_CONNECTION_STACK_SIZE,
+ .priority = g_connection_manager.config.connection_thread_priority
+ };
+
+ snprintf((char*)thread_attr.name, sizeof(thread_attr.name), "ai_conn_%s", g_service_names[service_type]);
+
+ conn->thread_id = osThreadNew(connection_thread_entry, (void*)service_type, &thread_attr);
+ if (conn->thread_id == NULL) {
+ AI_LOGE("Failed to create connection thread for service %s", g_service_names[service_type]);
+ return AI_ERROR_MEMORY_ALLOC;
+ }
+#else
+ AI_LOGI("TEST: Created connection thread for service %s", g_service_names[service_type]);
+ conn->thread_id = (void*)1; // 模拟线程ID
+#endif
+
+ return AI_OK;
+}
+
+static void connection_thread_entry(void *argument)
+{
+ ai_service_type_t service_type = (ai_service_type_t)(uintptr_t)argument;
+ ai_connection_info_t *conn = &g_connection_manager.connections[service_type];
+
+ AI_LOGI("Connection thread started for service %s", g_service_names[service_type]);
+
+ while (g_connection_manager.is_running) {
+ if (conn->state == AI_CONN_STATE_DISCONNECTED) {
+ /* 尝试连接 */
+ uint32_t connect_start = get_current_timestamp();
+
+ ai_error_t ret = websocket_connect(conn);
+ if (ret == AI_OK) {
+ uint32_t connect_time = get_current_timestamp() - connect_start;
+ g_connection_manager.metrics.connect_time_ms[service_type] = connect_time;
+ g_connection_manager.metrics.total_connect_time_ms += connect_time;
+
+ AI_LOGI("Service %s connected in %u ms", g_service_names[service_type], connect_time);
+
+ /* 更新连接状态矩阵 */
+ switch (service_type) {
+ case AI_SERVICE_ASR:
+ g_connection_manager.connection_matrix.asr_connected = 1;
+ break;
+ case AI_SERVICE_CHAT:
+ g_connection_manager.connection_matrix.chat_connected = 1;
+ break;
+ case AI_SERVICE_TTS:
+ g_connection_manager.connection_matrix.tts_connected = 1;
+ break;
+ case AI_SERVICE_COUNT:
+ /* 不应该到达这里 */
+ break;
+ }
+
+ update_global_state();
+
+#ifndef __TEST_MODE__
+ /* 释放就绪信号量 */
+ osSemaphoreRelease(conn->ready_semaphore);
+#endif
+
+ /* 发送连接建立事件 */
+ send_event(AI_EVENT_CONNECTION_ESTABLISHED, service_type, NULL);
+ } else {
+ conn->retry_count++;
+ g_connection_manager.metrics.retry_count[service_type]++;
+
+ AI_LOGW("Service %s connection failed, retry %d/%d",
+ g_service_names[service_type],
+ conn->retry_count,
+ g_connection_manager.config.max_retry_count);
+
+ if (conn->retry_count >= g_connection_manager.config.max_retry_count) {
+ AI_LOGE("Service %s connection failed after %d retries",
+ g_service_names[service_type], conn->retry_count);
+
+ /* 发送连接失败事件 */
+ send_event(AI_EVENT_ERROR_OCCURRED, service_type, &ret);
+ break;
+ }
+
+ /* 等待重试间隔 */
+#ifndef __TEST_MODE__
+ osDelay(g_connection_manager.config.retry_interval_ms);
+#endif
+ }
+ } else {
+ /* 连接已建立，等待断开或错误 */
+#ifndef __TEST_MODE__
+ osDelay(1000); // 1秒检查一次
+#endif
+ }
+ }
+
+ AI_LOGI("Connection thread exited for service %s", g_service_names[service_type]);
+}
+
+static void worker_thread_entry(void *argument)
+{
+ AI_LOGI("Worker thread started");
+
+ while (g_connection_manager.is_running) {
+#ifndef __TEST_MODE__
+ ai_event_t event;
+ osStatus_t status = osMessageQueueGet(g_connection_manager.event_queue, &event, NULL, 1000);
+
+ if (status == osOK) {
+ /* 处理事件 */
+ if (g_connection_manager.config.event_callback != NULL) {
+ g_connection_manager.config.event_callback(&event, g_connection_manager.config.user_data);
+ }
+ }
+#else
+ /* 测试模式下简单延时 */
+ usleep(100000); // 100ms
+#endif
+ }
+
+ AI_LOGI("Worker thread exited");
+}
+
+static ai_error_t websocket_connect(ai_connection_info_t *conn_info)
+{
+ if (conn_info == NULL || strlen(conn_info->url) == 0) {
+ return AI_ERROR_INVALID_PARAM;
+ }
+
+ AI_LOGI("Connecting to %s: %s", g_service_names[conn_info->service_type], conn_info->url);
+
+#ifndef __TEST_MODE__
+ /* 创建WebSocket客户端 */
+ conn_info->websocket = WebSocketClientConstructor(websocket_on_connected, websocket_on_message,
+ websocket_on_error, websocket_on_disconnected);
+ if (conn_info->websocket < 0) {
+ AI_LOGE("Failed to create WebSocket client: %d", conn_info->websocket);
+ return AI_ERROR_MEMORY_ALLOC;
+ }
+
+ /* 连接到服务器 */
+ int ret = WebSocketClientConnect(conn_info->websocket, conn_info->url);
+ if (ret != 0) {
+ AI_LOGE("WebSocket connection failed: %d", ret);
+ WebSocketClientClose(conn_info->websocket);
+ conn_info->websocket = -1;
+ return AI_ERROR_CONNECTION_FAILED;
+ }
+#else
+ /* 测试模式下模拟连接成功 */
+ conn_info->websocket = 1; // 模拟WebSocket文件描述符
+ conn_info->state = AI_CONN_STATE_CONNECTED;
+ AI_LOGI("TEST: Connected to %s", conn_info->url);
+#endif
+
+ conn_info->connect_time_ms = get_current_timestamp();
+ conn_info->last_activity_time = conn_info->connect_time_ms;
+ conn_info->retry_count = 0;
+
+ return AI_OK;
+}
+
+/* 通过WebSocket客户端fd查找连接信息 */
+static ai_connection_info_t* find_connection_by_websocket(int websocket_fd)
+{
+ for (int i = 0; i < AI_SERVICE_COUNT; i++) {
+ if (g_connection_manager.connections[i].websocket == websocket_fd) {
+ return &g_connection_manager.connections[i];
+ }
+ }
+ return NULL;
+}
+
+static void websocket_on_connected(int client)
+{
+ ai_connection_info_t *conn_info = find_connection_by_websocket(client);
+ if (conn_info == NULL) {
+ AI_LOGE("Cannot find connection info for WebSocket client %d", client);
+ return;
+ }
+
+ AI_LOGI("WebSocket connected for service %s", g_service_names[conn_info->service_type]);
+
+#ifndef __TEST_MODE__
+ if (conn_info->mutex != NULL) {
+ osMutexAcquire(conn_info->mutex, osWaitForever);
+ }
+#endif
+
+ conn_info->state = AI_CONN_STATE_CONNECTED;
+ conn_info->last_activity_time = get_current_timestamp();
+
+#ifndef __TEST_MODE__
+ if (conn_info->mutex != NULL) {
+ osMutexRelease(conn_info->mutex);
+ }
+#endif
+}
+
+static void websocket_on_message(int client, const char *data, size_t length, bool isFinished)
+{
+ (void)isFinished; // 暂时不处理分片消息
+ ai_connection_info_t *conn_info = find_connection_by_websocket(client);
+ if (conn_info == NULL || data == NULL || length == 0) {
+ return;
+ }
+
+ AI_LOGI("Received %zu bytes from service %s", length, g_service_names[conn_info->service_type]);
+
+ /* 更新统计 */
+ g_connection_manager.metrics.total_bytes_received += length;
+ conn_info->last_activity_time = get_current_timestamp();
+
+ /* 发送数据接收事件 */
+ ai_event_t event = {
+ .type = AI_EVENT_DATA_RECEIVED,
+ .service = conn_info->service_type,
+ .timestamp = get_current_timestamp()
+ };
+ event.payload.data.data = data;
+ event.payload.data.length = length;
+
+ send_event(AI_EVENT_DATA_RECEIVED, conn_info->service_type, &event.payload.data);
+}
+
+static void websocket_on_error(int client, struct WebSocketErrorResult errorResult)
+{
+ ai_connection_info_t *conn_info = find_connection_by_websocket(client);
+ if (conn_info == NULL) {
+ return;
+ }
+
+ AI_LOGE("WebSocket error for service %s: %d - %s",
+ g_service_names[conn_info->service_type], errorResult.errorCode,
+ errorResult.errorMessage ? errorResult.errorMessage : "Unknown");
+
+ conn_info->state = AI_CONN_STATE_ERROR;
+
+ /* 发送错误事件 */
+ send_event(AI_EVENT_ERROR_OCCURRED, conn_info->service_type, &errorResult.errorCode);
+}
+
+static void websocket_on_disconnected(int client)
+{
+ ai_connection_info_t *conn_info = find_connection_by_websocket(client);
+ if (conn_info == NULL) {
+ return;
+ }
+
+ AI_LOGW("WebSocket disconnected for service %s", g_service_names[conn_info->service_type]);
+
+ conn_info->state = AI_CONN_STATE_DISCONNECTED;
+
+ /* 更新连接状态矩阵 */
+ switch (conn_info->service_type) {
+ case AI_SERVICE_ASR:
+ g_connection_manager.connection_matrix.asr_connected = 0;
+ break;
+ case AI_SERVICE_CHAT:
+ g_connection_manager.connection_matrix.chat_connected = 0;
+ break;
+ case AI_SERVICE_TTS:
+ g_connection_manager.connection_matrix.tts_connected = 0;
+ break;
+ case AI_SERVICE_COUNT:
+ /* 不应该到达这里 */
+ break;
+ }
+
+ update_global_state();
+
+ /* 发送连接丢失事件 */
+ send_event(AI_EVENT_CONNECTION_LOST, conn_info->service_type, NULL);
+}
+
+static ai_error_t update_global_state(void)
+{
+ ai_connection_matrix_t matrix = g_connection_manager.connection_matrix;
+ ai_global_state_t old_state = g_connection_manager.global_state;
+ ai_global_state_t new_state;
+
+ /* 根据连接状态矩阵确定全局状态 */
+ if (matrix.asr_connected && matrix.chat_connected && matrix.tts_connected) {
+ new_state = AI_STATE_READY;
+ } else if (matrix.asr_connected && (matrix.chat_connected || matrix.tts_connected)) {
+ new_state = AI_STATE_PARTIAL;
+ } else if (matrix.asr_connected) {
+ new_state = AI_STATE_DEGRADED;
+ } else {
+ new_state = AI_STATE_CONNECTING;
+ }
+
+ if (old_state != new_state) {
+ g_connection_manager.global_state = new_state;
+
+ AI_LOGI("Global state changed: %s -> %s",
+ ai_connection_manager_get_state_name(old_state),
+ ai_connection_manager_get_state_name(new_state));
+
+ /* 发送状态变更事件 */
+ ai_event_t event = {
+ .type = AI_EVENT_STATE_CHANGED,
+ .service = AI_SERVICE_COUNT, // 表示全局事件
+ .timestamp = get_current_timestamp()
+ };
+ event.payload.state_change.old_state = old_state;
+ event.payload.state_change.new_state = new_state;
+
+ send_event(AI_EVENT_STATE_CHANGED, AI_SERVICE_COUNT, &event.payload.state_change);
+ }
+
+ return AI_OK;
+}
+
+static void send_event(ai_event_type_t type, ai_service_type_t service, const void *data)
+{
+ if (!g_connection_manager.is_running) {
+ return;
+ }
+
+ ai_event_t event = {
+ .type = type,
+ .service = service,
+ .timestamp = get_current_timestamp()
+ };
+
+ /* 根据事件类型复制数据 */
+ if (data != NULL) {
+ switch (type) {
+ case AI_EVENT_DATA_RECEIVED:
+ memcpy(&event.payload.data, data, sizeof(event.payload.data));
+ break;
+ case AI_EVENT_ERROR_OCCURRED:
+ event.payload.error.error_code = *(int*)data;
+ break;
+ case AI_EVENT_STATE_CHANGED:
+ memcpy(&event.payload.state_change, data, sizeof(event.payload.state_change));
+ break;
+ default:
+ break;
+ }
+ }
+
+#ifndef __TEST_MODE__
+ /* 发送到事件队列 */
+ if (g_connection_manager.event_queue != NULL) {
+ osMessageQueuePut(g_connection_manager.event_queue, &event, 0, 0);
+ }
+#endif
+
+ /* 直接调用回调函数 */
+ if (g_connection_manager.config.event_callback != NULL) {
+ g_connection_manager.config.event_callback(&event, g_connection_manager.config.user_data);
+ }
+}
+
+static uint32_t get_current_timestamp(void)
+{
+#ifndef __TEST_MODE__
+ return (uint32_t)(osKernelGetTickCount() * 1000 / osKernelGetTickFreq());
+#else
+ return 0; // 测试模式下返回固定值
+#endif
+}
+
+#ifndef __TEST_MODE__
+static void heartbeat_timer_callback(void *argument)
+{
+ if (!g_connection_manager.is_running) {
+ return;
+ }
+
+ uint32_t current_time = get_current_timestamp();
+
+ /* 检查各连接的活动状态 */
+ for (int i = 0; i < AI_SERVICE_COUNT; i++) {
+ ai_connection_info_t *conn = &g_connection_manager.connections[i];
+
+ if (conn->state == AI_CONN_STATE_CONNECTED) {
+ uint32_t inactive_time = current_time - conn->last_activity_time;
+
+ if (inactive_time > AI_HEARTBEAT_INTERVAL_MS * 2) {
+ AI_LOGW("Service %s inactive for %u ms, sending heartbeat",
+ g_service_names[i], inactive_time);
+
+ /* 发送心跳包 */
+ const char *heartbeat = "{\"type\":\"heartbeat\"}";
+ ai_connection_manager_send_data((ai_service_type_t)i, heartbeat, strlen(heartbeat));
+ }
+ }
+ }
+}
+#endif
+
+/* ================================ 调试和监控函数实现 ================================ */
+
+void ai_connection_manager_print_status(void)
+{
+ if (!g_manager_initialized) {
+ printf("Connection manager not initialized\n");
+ return;
+ }
+
+ printf("\n=== AI Connection Manager Status ===\n");
+ printf("Global State: %s\n", ai_connection_manager_get_state_name(g_connection_manager.global_state));
+ printf("Running: %s\n", g_connection_manager.is_running ? "Yes" : "No");
+ printf("Init Time: %u ms\n", g_connection_manager.init_timestamp);
+
+ printf("\nConnection Matrix:\n");
+ printf(" ASR: %s\n", g_connection_manager.connection_matrix.asr_connected ? "Connected" : "Disconnected");
+ printf(" Chat: %s\n", g_connection_manager.connection_matrix.chat_connected ? "Connected" : "Disconnected");
+ printf(" TTS: %s\n", g_connection_manager.connection_matrix.tts_connected ? "Connected" : "Disconnected");
+
+ printf("\nService Details:\n");
+ for (int i = 0; i < AI_SERVICE_COUNT; i++) {
+ ai_connection_info_t *conn = &g_connection_manager.connections[i];
+ printf(" %s:\n", g_service_names[i]);
+ printf(" URL: %s\n", conn->url);
+ printf(" State: %d\n", conn->state);
+ printf(" Connect Time: %u ms\n", conn->connect_time_ms);
+ printf(" Last Activity: %u ms\n", conn->last_activity_time);
+ printf(" Retry Count: %d\n", conn->retry_count);
+ }
+ printf("=====================================\n\n");
+}
+
+void ai_connection_manager_print_metrics(void)
+{
+ if (!g_manager_initialized) {
+ printf("Connection manager not initialized\n");
+ return;
+ }
+
+ const ai_connect_metrics_t *metrics = &g_connection_manager.metrics;
+
+ printf("\n=== Connection Metrics ===\n");
+ printf("Total Connect Time: %u ms\n", metrics->total_connect_time_ms);
+ printf("Last Connect Time: %u ms\n", metrics->last_connect_timestamp);
+ printf("Success Rate: %d%%\n", metrics->success_rate);
+ printf("Total Bytes Sent: %u\n", metrics->total_bytes_sent);
+ printf("Total Bytes Received: %u\n", metrics->total_bytes_received);
+
+ printf("\nPer-Service Metrics:\n");
+ for (int i = 0; i < AI_SERVICE_COUNT; i++) {
+ printf(" %s:\n", g_service_names[i]);
+ printf(" Connect Time: %u ms\n", metrics->connect_time_ms[i]);
+ printf(" Retry Count: %d\n", metrics->retry_count[i]);
+ }
+ printf("==========================\n\n");
+}
+
+void ai_connection_manager_reset_metrics(void)
+{
+ if (!g_manager_initialized) {
+ return;
+ }
+
+ memset(&g_connection_manager.metrics, 0, sizeof(ai_connect_metrics_t));
+ AI_LOGI("Connection metrics reset");
+}
\ No newline at end of file
--- /dev/null
+/**
+ * @file ai_memory_pool.c
+ * @brief AI智能内存池管理器实现 - LiteOS-M优化版v2
+ * @version 2.0
+ * @date 2024-01-20
+ */
+
+#include "ai_memory_pool.h"
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifndef __TEST_MODE__
+#include "wearable_log.h"
+#define AI_LOG_TAG "AI_MEM_POOL"
+#define AI_LOGI(fmt, ...) WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] " fmt, AI_LOG_TAG, ##__VA_ARGS__)
+#define AI_LOGE(fmt, ...) WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] " fmt, AI_LOG_TAG, ##__VA_ARGS__)
+#define AI_LOGW(fmt, ...) WEARABLE_LOGW(WEARABLE_LOG_MODULE_APP, "[%s] " fmt, AI_LOG_TAG, ##__VA_ARGS__)
+#else
+#define AI_LOGI(fmt, ...) printf("[AI_MEM_POOL] " fmt "\n", ##__VA_ARGS__)
+#define AI_LOGE(fmt, ...) printf("[AI_MEM_POOL] ERROR: " fmt "\n", ##__VA_ARGS__)
+#define AI_LOGW(fmt, ...) printf("[AI_MEM_POOL] WARN: " fmt "\n", ##__VA_ARGS__)
+#endif
+
+/* ================================ 全局变量 ================================ */
+
+static ai_memory_pool_manager_t g_pool_manager = {0};
+static bool g_pool_initialized = false;
+
+/* 池类型名称映射表 */
+static const char* g_pool_type_names[AI_POOL_TYPE_COUNT] = {
+ "AUDIO_IN", "AUDIO_OUT", "NETWORK", "CONNECTION"
+};
+
+/* 默认池配置 */
+static const struct {
+ uint32_t pool_size;
+ uint16_t block_size;
+ uint16_t block_count;
+} g_default_pool_configs[AI_POOL_TYPE_COUNT] = {
+ {AI_AUDIO_IN_BUFFER_SIZE * 2, AI_AUDIO_IN_BUFFER_SIZE, 2}, // AUDIO_IN: 2个2KB块
+ {AI_AUDIO_OUT_BUFFER_SIZE * 2, AI_AUDIO_OUT_BUFFER_SIZE, 2}, // AUDIO_OUT: 2个1KB块
+ {AI_NETWORK_POOL_SIZE, 256, 12}, // NETWORK: 12个256B块
+ {AI_CONNECTION_BUFFER_SIZE * 3, AI_CONNECTION_BUFFER_SIZE, 3} // CONNECTION: 3个1KB块
+};
+
+/* ================================ 内部函数声明 ================================ */
+
+static ai_error_t pool_init_single(ai_pool_type_t pool_type, const ai_memory_pool_config_t *config);
+static ai_error_t pool_destroy_single(ai_pool_type_t pool_type);
+static ai_memory_block_t* block_alloc_from_pool(ai_memory_pool_t *pool, uint16_t size, ai_service_type_t service);
+static ai_error_t block_free_to_pool(ai_memory_pool_t *pool, ai_memory_block_t *block);
+static ai_error_t pool_defragment_single(ai_memory_pool_t *pool);
+static void pool_update_stats(ai_memory_pool_t *pool);
+static uint32_t get_current_timestamp(void);
+static ai_memory_block_t* find_block_by_buffer(const ai_buffer_t *buffer);
+static bool validate_block_integrity(const ai_memory_block_t *block);
+
+#ifndef __TEST_MODE__
+static void gc_timer_callback(void *argument);
+#endif
+
+/* ================================ 公共接口实现 ================================ */
+
+ai_error_t ai_memory_pool_init(const ai_memory_pool_config_t *config)
+{
+ if (config == NULL) {
+ AI_LOGE("Invalid config parameter");
+ return AI_ERROR_INVALID_PARAM;
+ }
+
+ if (g_pool_initialized) {
+ AI_LOGW("Memory pool already initialized");
+ return AI_ERROR_ALREADY_INITIALIZED;
+ }
+
+ AI_LOGI("Initializing memory pool manager...");
+
+ /* 清空管理器结构 */
+ memset(&g_pool_manager, 0, sizeof(g_pool_manager));
+
+ /* 复制配置 */
+ g_pool_manager.enable_boundary_check = config->enable_boundary_check;
+ g_pool_manager.enable_auto_defrag = config->enable_auto_defrag;
+ g_pool_manager.defrag_threshold = config->defrag_threshold;
+ g_pool_manager.gc_interval_ms = config->gc_interval_ms;
+ g_pool_manager.init_timestamp = get_current_timestamp();
+
+#ifndef __TEST_MODE__
+ /* 创建全局互斥锁 */
+ g_pool_manager.global_mutex = osMutexNew(NULL);
+ if (g_pool_manager.global_mutex == NULL) {
+ AI_LOGE("Failed to create global mutex");
+ return AI_ERROR_MEMORY_ALLOC;
+ }
+
+ /* 创建垃圾回收定时器 */
+ if (config->gc_interval_ms > 0) {
+ g_pool_manager.gc_timer = osTimerNew(gc_timer_callback, osTimerPeriodic, NULL, NULL);
+ if (g_pool_manager.gc_timer == NULL) {
+ AI_LOGW("Failed to create GC timer");
+ }
+ }
+#endif
+
+ /* 初始化各个内存池 */
+ for (int i = 0; i < AI_POOL_TYPE_COUNT; i++) {
+ ai_error_t ret = pool_init_single((ai_pool_type_t)i, config);
+ if (ret != AI_OK) {
+ AI_LOGE("Failed to initialize pool %s", g_pool_type_names[i]);
+
+ /* 清理已初始化的池 */
+ for (int j = 0; j < i; j++) {
+ pool_destroy_single((ai_pool_type_t)j);
+ }
+
+#ifndef __TEST_MODE__
+ if (g_pool_manager.global_mutex != NULL) {
+ osMutexDelete(g_pool_manager.global_mutex);
+ }
+ if (g_pool_manager.gc_timer != NULL) {
+ osTimerDelete(g_pool_manager.gc_timer);
+ }
+#endif
+ return ret;
+ }
+ }
+
+#ifndef __TEST_MODE__
+ /* 启动垃圾回收定时器 */
+ if (g_pool_manager.gc_timer != NULL) {
+ osTimerStart(g_pool_manager.gc_timer, config->gc_interval_ms);
+ }
+#endif
+
+ g_pool_manager.is_initialized = true;
+ g_pool_initialized = true;
+
+ AI_LOGI("Memory pool manager initialized successfully");
+ ai_memory_pool_print_statistics();
+
+ return AI_OK;
+}
+
+ai_error_t ai_memory_pool_destroy(void)
+{
+ if (!g_pool_initialized) {
+ return AI_ERROR_NOT_INITIALIZED;
+ }
+
+ AI_LOGI("Destroying memory pool manager...");
+
+#ifndef __TEST_MODE__
+ /* 停止垃圾回收定时器 */
+ if (g_pool_manager.gc_timer != NULL) {
+ osTimerStop(g_pool_manager.gc_timer);
+ osTimerDelete(g_pool_manager.gc_timer);
+ g_pool_manager.gc_timer = NULL;
+ }
+#endif
+
+ /* 检查内存泄漏 */
+ uint16_t leak_count = ai_memory_pool_check_leaks();
+ if (leak_count > 0) {
+ AI_LOGW("Detected %d memory leaks before destruction", leak_count);
+ }
+
+ /* 销毁各个内存池 */
+ for (int i = 0; i < AI_POOL_TYPE_COUNT; i++) {
+ pool_destroy_single((ai_pool_type_t)i);
+ }
+
+#ifndef __TEST_MODE__
+ /* 删除全局互斥锁 */
+ if (g_pool_manager.global_mutex != NULL) {
+ osMutexDelete(g_pool_manager.global_mutex);
+ g_pool_manager.global_mutex = NULL;
+ }
+#endif
+
+ /* 重置状态 */
+ memset(&g_pool_manager, 0, sizeof(g_pool_manager));
+ g_pool_initialized = false;
+
+ AI_LOGI("Memory pool manager destroyed");
+ return AI_OK;
+}
+
+ai_buffer_t* ai_memory_pool_alloc(ai_pool_type_t pool_type, uint16_t size, ai_service_type_t service_type)
+{
+ if (!g_pool_initialized) {
+ AI_LOGE("Memory pool not initialized");
+ return NULL;
+ }
+
+ if (pool_type >= AI_POOL_TYPE_COUNT || size == 0) {
+ AI_LOGE("Invalid parameters: pool_type=%d, size=%d", pool_type, size);
+ return NULL;
+ }
+
+ ai_memory_pool_t *pool = &g_pool_manager.pools[pool_type];
+
+#ifndef __TEST_MODE__
+ if (pool->mutex != NULL) {
+ osMutexAcquire(pool->mutex, osWaitForever);
+ }
+#endif
+
+ ai_memory_block_t *block = block_alloc_from_pool(pool, size, service_type);
+
+#ifndef __TEST_MODE__
+ if (pool->mutex != NULL) {
+ osMutexRelease(pool->mutex);
+ }
+#endif
+
+ if (block == NULL) {
+ AI_LOGW("Failed to allocate %d bytes from pool %s", size, g_pool_type_names[pool_type]);
+ return NULL;
+ }
+
+ /* 创建缓冲区结构 */
+ ai_buffer_t *buffer = (ai_buffer_t*)malloc(sizeof(ai_buffer_t));
+ if (buffer == NULL) {
+ AI_LOGE("Failed to allocate buffer structure");
+ block_free_to_pool(pool, block);
+ return NULL;
+ }
+
+ buffer->buffer = block->data;
+ buffer->size = block->size;
+ buffer->used = 0;
+ buffer->service_id = service_type;
+ buffer->is_allocated = true;
+
+ AI_LOGI("Allocated %d bytes from pool %s for service %d",
+ size, g_pool_type_names[pool_type], service_type);
+
+ return buffer;
+}
+
+ai_error_t ai_memory_pool_free(ai_buffer_t *buffer)
+{
+ if (!g_pool_initialized) {
+ return AI_ERROR_NOT_INITIALIZED;
+ }
+
+ if (buffer == NULL || !buffer->is_allocated) {
+ return AI_ERROR_INVALID_PARAM;
+ }
+
+ /* 查找对应的内存块 */
+ ai_memory_block_t *block = find_block_by_buffer(buffer);
+ if (block == NULL) {
+ AI_LOGE("Invalid buffer: cannot find corresponding memory block");
+ return AI_ERROR_INVALID_PARAM;
+ }
+
+ /* 边界检查 */
+ if (g_pool_manager.enable_boundary_check && !validate_block_integrity(block)) {
+ AI_LOGE("Buffer corruption detected during free");
+ return AI_ERROR_BUFFER_OVERFLOW;
+ }
+
+ /* 找到对应的池 */
+ ai_memory_pool_t *pool = NULL;
+ for (int i = 0; i < AI_POOL_TYPE_COUNT; i++) {
+ if (g_pool_manager.pools[i].pool_base <= block->data &&
+ block->data < g_pool_manager.pools[i].pool_base + g_pool_manager.pools[i].pool_size) {
+ pool = &g_pool_manager.pools[i];
+ break;
+ }
+ }
+
+ if (pool == NULL) {
+ AI_LOGE("Cannot find pool for buffer");
+ return AI_ERROR_INVALID_PARAM;
+ }
+
+#ifndef __TEST_MODE__
+ if (pool->mutex != NULL) {
+ osMutexAcquire(pool->mutex, osWaitForever);
+ }
+#endif
+
+ ai_error_t ret = block_free_to_pool(pool, block);
+
+#ifndef __TEST_MODE__
+ if (pool->mutex != NULL) {
+ osMutexRelease(pool->mutex);
+ }
+#endif
+
+ if (ret == AI_OK) {
+ buffer->is_allocated = false;
+ free(buffer);
+ AI_LOGI("Buffer freed successfully");
+ }
+
+ return ret;
+}
+
+ai_error_t ai_memory_pool_resize(ai_buffer_t *buffer, uint16_t new_size)
+{
+ if (!g_pool_initialized || buffer == NULL || !buffer->is_allocated) {
+ return AI_ERROR_INVALID_PARAM;
+ }
+
+ if (new_size == 0) {
+ return AI_ERROR_INVALID_PARAM;
+ }
+
+ /* 如果新大小小于等于当前大小，直接调整 */
+ if (new_size <= buffer->size) {
+ buffer->used = (buffer->used > new_size) ? new_size : buffer->used;
+ return AI_OK;
+ }
+
+ /* 需要重新分配更大的缓冲区 */
+ ai_memory_block_t *old_block = find_block_by_buffer(buffer);
+ if (old_block == NULL) {
+ return AI_ERROR_INVALID_PARAM;
+ }
+
+ /* 确定池类型 */
+ ai_pool_type_t pool_type = AI_POOL_TYPE_COUNT;
+ for (int i = 0; i < AI_POOL_TYPE_COUNT; i++) {
+ if (g_pool_manager.pools[i].pool_base <= old_block->data &&
+ old_block->data < g_pool_manager.pools[i].pool_base + g_pool_manager.pools[i].pool_size) {
+ pool_type = (ai_pool_type_t)i;
+ break;
+ }
+ }
+
+ if (pool_type >= AI_POOL_TYPE_COUNT) {
+ return AI_ERROR_INVALID_PARAM;
+ }
+
+ /* 分配新缓冲区 */
+ ai_buffer_t *new_buffer = ai_memory_pool_alloc(pool_type, new_size, buffer->service_id);
+ if (new_buffer == NULL) {
+ return AI_ERROR_MEMORY_ALLOC;
+ }
+
+ /* 复制数据 */
+ if (buffer->used > 0) {
+ memcpy(new_buffer->buffer, buffer->buffer, buffer->used);
+ new_buffer->used = buffer->used;
+ }
+
+ /* 释放旧缓冲区 */
+ ai_memory_pool_free(buffer);
+
+ /* 更新缓冲区信息 */
+ buffer->buffer = new_buffer->buffer;
+ buffer->size = new_buffer->size;
+ buffer->used = new_buffer->used;
+
+ /* 释放临时缓冲区结构 */
+ free(new_buffer);
+
+ AI_LOGI("Buffer resized from %d to %d bytes", buffer->size, new_size);
+ return AI_OK;
+}
+
+const ai_memory_stats_t* ai_memory_pool_get_stats(ai_pool_type_t pool_type)
+{
+ if (!g_pool_initialized || pool_type >= AI_POOL_TYPE_COUNT) {
+ return NULL;
+ }
+
+ ai_memory_pool_t *pool = &g_pool_manager.pools[pool_type];
+
+ /* 更新统计信息 */
+ pool_update_stats(pool);
+
+ return (const ai_memory_stats_t*)&pool->total_allocs; // 简化映射
+}
+
+const ai_memory_stats_t* ai_memory_pool_get_global_stats(void)
+{
+ if (!g_pool_initialized) {
+ return NULL;
+ }
+
+ /* 更新全局统计 */
+ memset(&g_pool_manager.global_stats, 0, sizeof(ai_memory_stats_t));
+
+ for (int i = 0; i < AI_POOL_TYPE_COUNT; i++) {
+ ai_memory_pool_t *pool = &g_pool_manager.pools[i];
+ pool_update_stats(pool);
+
+ g_pool_manager.global_stats.total_size += pool->pool_size;
+ g_pool_manager.global_stats.used_size += pool->current_usage;
+ g_pool_manager.global_stats.alloc_count += pool->total_allocs;
+ g_pool_manager.global_stats.free_count += pool->total_frees;
+ }
+
+ g_pool_manager.global_stats.free_size =
+ g_pool_manager.global_stats.total_size - g_pool_manager.global_stats.used_size;
+
+ if (g_pool_manager.global_stats.total_size > 0) {
+ g_pool_manager.global_stats.fragmentation =
+ (uint8_t)((g_pool_manager.global_stats.used_size * 100) / g_pool_manager.global_stats.total_size);
+ }
+
+ return &g_pool_manager.global_stats;
+}
+
+/* ================================ 智能分配函数实现 ================================ */
+
+ai_buffer_t* ai_memory_pool_alloc_audio_in(ai_service_type_t service_type)
+{
+ return ai_memory_pool_alloc(AI_POOL_TYPE_AUDIO_IN, AI_AUDIO_IN_BUFFER_SIZE, service_type);
+}
+
+ai_buffer_t* ai_memory_pool_alloc_audio_out(ai_service_type_t service_type)
+{
+ return ai_memory_pool_alloc(AI_POOL_TYPE_AUDIO_OUT, AI_AUDIO_OUT_BUFFER_SIZE, service_type);
+}
+
+ai_buffer_t* ai_memory_pool_alloc_network(ai_service_type_t service_type, uint16_t size)
+{
+ /* 网络缓冲区支持动态大小 */
+ uint16_t alloc_size = (size <= 256) ? 256 :
+ (size <= 512) ? 512 :
+ (size <= 1024) ? 1024 : size;
+
+ return ai_memory_pool_alloc(AI_POOL_TYPE_NETWORK, alloc_size, service_type);
+}
+
+ai_buffer_t* ai_memory_pool_alloc_connection(ai_service_type_t service_type)
+{
+ return ai_memory_pool_alloc(AI_POOL_TYPE_CONNECTION, AI_CONNECTION_BUFFER_SIZE, service_type);
+}
+
+/* ================================ 配置辅助函数实现 ================================ */
+
+void ai_memory_pool_create_default_config(ai_memory_pool_config_t *config)
+{
+ if (config == NULL) {
+ return;
+ }
+
+ memset(config, 0, sizeof(ai_memory_pool_config_t));
+
+ /* 使用默认池配置 */
+ config->audio_in_pool_size = g_default_pool_configs[AI_POOL_TYPE_AUDIO_IN].pool_size;
+ config->audio_out_pool_size = g_default_pool_configs[AI_POOL_TYPE_AUDIO_OUT].pool_size;
+ config->network_pool_size = g_default_pool_configs[AI_POOL_TYPE_NETWORK].pool_size;
+ config->connection_pool_size = g_default_pool_configs[AI_POOL_TYPE_CONNECTION].pool_size;
+
+ config->audio_in_block_size = g_default_pool_configs[AI_POOL_TYPE_AUDIO_IN].block_size;
+ config->audio_out_block_size = g_default_pool_configs[AI_POOL_TYPE_AUDIO_OUT].block_size;
+ config->network_block_size = g_default_pool_configs[AI_POOL_TYPE_NETWORK].block_size;
+ config->connection_block_size = g_default_pool_configs[AI_POOL_TYPE_CONNECTION].block_size;
+
+ /* 管理配置 */
+ config->enable_boundary_check = true;
+ config->enable_auto_defrag = true;
+ config->defrag_threshold = 75; // 75%碎片率触发整理
+ config->gc_interval_ms = 30000; // 30秒垃圾回收间隔
+}
+
+const char* ai_memory_pool_get_type_name(ai_pool_type_t pool_type)
+{
+ if (pool_type >= AI_POOL_TYPE_COUNT) {
+ return "UNKNOWN";
+ }
+
+ return g_pool_type_names[pool_type];
+}
+
+/* ================================ 内部函数实现 ================================ */
+
+static ai_error_t pool_init_single(ai_pool_type_t pool_type, const ai_memory_pool_config_t *config)
+{
+ ai_memory_pool_t *pool = &g_pool_manager.pools[pool_type];
+
+ /* 获取池配置 */
+ uint32_t pool_size;
+ uint16_t block_size;
+
+ switch (pool_type) {
+ case AI_POOL_TYPE_AUDIO_IN:
+ pool_size = config->audio_in_pool_size;
+ block_size = config->audio_in_block_size;
+ break;
+ case AI_POOL_TYPE_AUDIO_OUT:
+ pool_size = config->audio_out_pool_size;
+ block_size = config->audio_out_block_size;
+ break;
+ case AI_POOL_TYPE_NETWORK:
+ pool_size = config->network_pool_size;
+ block_size = config->network_block_size;
+ break;
+ case AI_POOL_TYPE_CONNECTION:
+ pool_size = config->connection_pool_size;
+ block_size = config->connection_block_size;
+ break;
+ default:
+ return AI_ERROR_INVALID_PARAM;
+ }
+
+ /* 初始化池结构 */
+ pool->type = pool_type;
+ pool->pool_size = pool_size;
+ pool->block_size = block_size;
+ pool->block_count = pool_size / block_size;
+ pool->free_count = pool->block_count;
+
+ /* 分配池内存 */
+ pool->pool_base = (uint8_t*)malloc(pool_size);
+ if (pool->pool_base == NULL) {
+ AI_LOGE("Failed to allocate pool memory for %s", g_pool_type_names[pool_type]);
+ return AI_ERROR_MEMORY_ALLOC;
+ }
+
+ /* 分配块结构数组 */
+ pool->blocks = (ai_memory_block_t*)malloc(sizeof(ai_memory_block_t) * pool->block_count);
+ if (pool->blocks == NULL) {
+ AI_LOGE("Failed to allocate block structures for %s", g_pool_type_names[pool_type]);
+ free(pool->pool_base);
+ return AI_ERROR_MEMORY_ALLOC;
+ }
+
+#ifndef __TEST_MODE__
+ /* 创建池互斥锁 */
+ pool->mutex = osMutexNew(NULL);
+ if (pool->mutex == NULL) {
+ AI_LOGE("Failed to create mutex for pool %s", g_pool_type_names[pool_type]);
+ free(pool->pool_base);
+ free(pool->blocks);
+ return AI_ERROR_MEMORY_ALLOC;
+ }
+#endif
+
+ /* 初始化内存块 */
+ for (int i = 0; i < pool->block_count; i++) {
+ ai_memory_block_t *block = &pool->blocks[i];
+ block->data = pool->pool_base + (i * block_size);
+ block->size = block_size;
+ block->used = 0;
+ block->state = AI_BUFFER_STATE_FREE;
+ block->owner_service = AI_SERVICE_COUNT; // 无所有者
+ block->alloc_timestamp = 0;
+ block->next = (i < pool->block_count - 1) ? &pool->blocks[i + 1] : NULL;
+ block->prev = (i > 0) ? &pool->blocks[i - 1] : NULL;
+ }
+
+ /* 设置空闲链表 */
+ pool->free_list = &pool->blocks[0];
+ pool->used_list = NULL;
+
+ AI_LOGI("Pool %s initialized: %d blocks of %d bytes each (%d KB total)",
+ g_pool_type_names[pool_type], pool->block_count, block_size, pool_size / 1024);
+
+ return AI_OK;
+}
+
+static ai_error_t pool_destroy_single(ai_pool_type_t pool_type)
+{
+ ai_memory_pool_t *pool = &g_pool_manager.pools[pool_type];
+
+ if (pool->pool_base == NULL) {
+ return AI_OK; // 已经销毁或未初始化
+ }
+
+ AI_LOGI("Destroying pool %s...", g_pool_type_names[pool_type]);
+
+ /* 检查是否有未释放的块 */
+ if (pool->free_count < pool->block_count) {
+ AI_LOGW("Pool %s has %d unreleased blocks",
+ g_pool_type_names[pool_type],
+ pool->block_count - pool->free_count);
+ }
+
+#ifndef __TEST_MODE__
+ /* 删除互斥锁 */
+ if (pool->mutex != NULL) {
+ osMutexDelete(pool->mutex);
+ pool->mutex = NULL;
+ }
+#endif
+
+ /* 释放内存 */
+ if (pool->pool_base != NULL) {
+ free(pool->pool_base);
+ pool->pool_base = NULL;
+ }
+
+ if (pool->blocks != NULL) {
+ free(pool->blocks);
+ pool->blocks = NULL;
+ }
+
+ /* 重置池结构 */
+ memset(pool, 0, sizeof(ai_memory_pool_t));
+
+ return AI_OK;
+}
+
+static ai_memory_block_t* block_alloc_from_pool(ai_memory_pool_t *pool, uint16_t size, ai_service_type_t service)
+{
+ if (pool->free_list == NULL || size > pool->block_size) {
+ return NULL;
+ }
+
+ /* 从空闲链表头部取出一个块 */
+ ai_memory_block_t *block = pool->free_list;
+ pool->free_list = block->next;
+
+ if (pool->free_list != NULL) {
+ pool->free_list->prev = NULL;
+ }
+
+ /* 添加到已用链表 */
+ block->next = pool->used_list;
+ block->prev = NULL;
+ if (pool->used_list != NULL) {
+ pool->used_list->prev = block;
+ }
+ pool->used_list = block;
+
+ /* 设置块信息 */
+ block->used = size;
+ block->state = AI_BUFFER_STATE_ALLOCATED;
+ block->owner_service = service;
+ block->alloc_timestamp = get_current_timestamp();
+
+ /* 更新统计 */
+ pool->free_count--;
+ pool->total_allocs++;
+ pool->current_usage += size;
+
+ if (pool->current_usage > pool->peak_usage) {
+ pool->peak_usage = pool->current_usage;
+ }
+
+ return block;
+}
+
+static ai_error_t block_free_to_pool(ai_memory_pool_t *pool, ai_memory_block_t *block)
+{
+ if (block == NULL || block->state != AI_BUFFER_STATE_ALLOCATED) {
+ return AI_ERROR_INVALID_PARAM;
+ }
+
+ /* 从已用链表移除 */
+ if (block->prev != NULL) {
+ block->prev->next = block->next;
+ } else {
+ pool->used_list = block->next;
+ }
+
+ if (block->next != NULL) {
+ block->next->prev = block->prev;
+ }
+
+ /* 添加到空闲链表头部 */
+ block->next = pool->free_list;
+ block->prev = NULL;
+ if (pool->free_list != NULL) {
+ pool->free_list->prev = block;
+ }
+ pool->free_list = block;
+
+ /* 重置块信息 */
+ uint16_t freed_size = block->used;
+ block->used = 0;
+ block->state = AI_BUFFER_STATE_FREE;
+ block->owner_service = AI_SERVICE_COUNT;
+ block->alloc_timestamp = 0;
+
+ /* 更新统计 */
+ pool->free_count++;
+ pool->total_frees++;
+ pool->current_usage -= freed_size;
+
+ return AI_OK;
+}
+
+static ai_memory_block_t* find_block_by_buffer(const ai_buffer_t *buffer)
+{
+ if (buffer == NULL || !buffer->is_allocated) {
+ return NULL;
+ }
+
+ /* 在所有池中查找对应的块 */
+ for (int i = 0; i < AI_POOL_TYPE_COUNT; i++) {
+ ai_memory_pool_t *pool = &g_pool_manager.pools[i];
+
+ if (pool->pool_base == NULL) {
+ continue;
+ }
+
+ /* 检查地址是否在池范围内 */
+ if (buffer->buffer >= pool->pool_base &&
+ buffer->buffer < pool->pool_base + pool->pool_size) {
+
+ /* 计算块索引 */
+ size_t offset = buffer->buffer - pool->pool_base;
+ size_t block_index = offset / pool->block_size;
+
+ if (block_index < pool->block_count) {
+ ai_memory_block_t *block = &pool->blocks[block_index];
+ if (block->data == buffer->buffer && block->state == AI_BUFFER_STATE_ALLOCATED) {
+ return block;
+ }
+ }
+ }
+ }
+
+ return NULL;
+}
+
+static bool validate_block_integrity(const ai_memory_block_t *block)
+{
+ if (block == NULL) {
+ return false;
+ }
+
+ /* 检查块状态 */
+ if (block->state != AI_BUFFER_STATE_ALLOCATED) {
+ return false;
+ }
+
+ /* 检查使用大小 */
+ if (block->used > block->size) {
+ return false;
+ }
+
+ /* 检查数据指针 */
+ if (block->data == NULL) {
+ return false;
+ }
+
+ return true;
+}
+
+static void pool_update_stats(ai_memory_pool_t *pool)
+{
+ if (pool == NULL || pool->pool_base == NULL) {
+ return;
+ }
+
+ /* 计算碎片化程度 */
+ if (pool->block_count > 0) {
+ uint16_t used_blocks = pool->block_count - pool->free_count;
+ pool->fragmentation_level = (uint8_t)((used_blocks * 100) / pool->block_count);
+ }
+}
+
+static uint32_t get_current_timestamp(void)
+{
+#ifndef __TEST_MODE__
+ return (uint32_t)(osKernelGetTickCount() * 1000 / osKernelGetTickFreq());
+#else
+ return 0; // 测试模式下返回固定值
+#endif
+}
+
+#ifndef __TEST_MODE__
+static void gc_timer_callback(void *argument)
+{
+ if (!g_pool_manager.is_initialized) {
+ return;
+ }
+
+ AI_LOGI("Running garbage collection...");
+
+ /* 检查各池的碎片化程度 */
+ for (int i = 0; i < AI_POOL_TYPE_COUNT; i++) {
+ ai_memory_pool_t *pool = &g_pool_manager.pools[i];
+ pool_update_stats(pool);
+
+ if (pool->fragmentation_level >= g_pool_manager.defrag_threshold) {
+ AI_LOGI("Pool %s fragmentation %d%%, triggering defragmentation",
+ g_pool_type_names[i], pool->fragmentation_level);
+
+ if (g_pool_manager.enable_auto_defrag) {
+ ai_memory_pool_defragment((ai_pool_type_t)i);
+ }
+ }
+ }
+}
+#endif
+
+/* ================================ 调试和监控函数实现 ================================ */
+
+void ai_memory_pool_print_status(ai_pool_type_t pool_type)
+{
+ if (!g_pool_initialized) {
+ printf("Memory pool not initialized\n");
+ return;
+ }
+
+ if (pool_type == AI_POOL_TYPE_COUNT) {
+ /* 打印所有池状态 */
+ printf("\n=== Memory Pool Status ===\n");
+ for (int i = 0; i < AI_POOL_TYPE_COUNT; i++) {
+ ai_memory_pool_print_status((ai_pool_type_t)i);
+ }
+ printf("==========================\n\n");
+ return;
+ }
+
+ if (pool_type >= AI_POOL_TYPE_COUNT) {
+ printf("Invalid pool type\n");
+ return;
+ }
+
+ ai_memory_pool_t *pool = &g_pool_manager.pools[pool_type];
+ pool_update_stats(pool);
+
+ printf("Pool %s:\n", g_pool_type_names[pool_type]);
+ printf(" Total Size: %u bytes (%u KB)\n", pool->pool_size, pool->pool_size / 1024);
+ printf(" Block Size: %u bytes\n", pool->block_size);
+ printf(" Block Count: %u\n", pool->block_count);
+ printf(" Free Blocks: %u\n", pool->free_count);
+ printf(" Used Blocks: %u\n", pool->block_count - pool->free_count);
+ printf(" Current Usage: %u bytes\n", pool->current_usage);
+ printf(" Peak Usage: %u bytes\n", pool->peak_usage);
+ printf(" Fragmentation: %u%%\n", pool->fragmentation_level);
+ printf(" Total Allocs: %u\n", pool->total_allocs);
+ printf(" Total Frees: %u\n", pool->total_frees);
+}
+
+void ai_memory_pool_print_statistics(void)
+{
+ if (!g_pool_initialized) {
+ printf("Memory pool not initialized\n");
+ return;
+ }
+
+ const ai_memory_stats_t *stats = ai_memory_pool_get_global_stats();
+ if (stats == NULL) {
+ return;
+ }
+
+ printf("\n=== Global Memory Statistics ===\n");
+ printf("Total Size: %u bytes (%u KB)\n", stats->total_size, stats->total_size / 1024);
+ printf("Used Size: %u bytes (%u KB)\n", stats->used_size, stats->used_size / 1024);
+ printf("Free Size: %u bytes (%u KB)\n", stats->free_size, stats->free_size / 1024);
+ printf("Total Allocations: %u\n", stats->alloc_count);
+ printf("Total Frees: %u\n", stats->free_count);
+ printf("Overall Fragmentation: %u%%\n", stats->fragmentation);
+ printf("================================\n\n");
+}
+
+uint16_t ai_memory_pool_check_leaks(void)
+{
+ if (!g_pool_initialized) {
+ return 0;
+ }
+
+ uint16_t leak_count = 0;
+
+ for (int i = 0; i < AI_POOL_TYPE_COUNT; i++) {
+ ai_memory_pool_t *pool = &g_pool_manager.pools[i];
+ uint16_t used_blocks = pool->block_count - pool->free_count;
+
+ if (used_blocks > 0) {
+ AI_LOGW("Pool %s has %d unreleased blocks", g_pool_type_names[i], used_blocks);
+ leak_count += used_blocks;
+ }
+ }
+
+ return leak_count;
+}
+
+void ai_memory_pool_reset_stats(ai_pool_type_t pool_type)
+{
+ if (!g_pool_initialized) {
+ return;
+ }
+
+ if (pool_type == AI_POOL_TYPE_COUNT) {
+ /* 重置所有池统计 */
+ for (int i = 0; i < AI_POOL_TYPE_COUNT; i++) {
+ ai_memory_pool_reset_stats((ai_pool_type_t)i);
+ }
+ memset(&g_pool_manager.global_stats, 0, sizeof(ai_memory_stats_t));
+ return;
+ }
+
+ if (pool_type >= AI_POOL_TYPE_COUNT) {
+ return;
+ }
+
+ ai_memory_pool_t *pool = &g_pool_manager.pools[pool_type];
+ pool->total_allocs = 0;
+ pool->total_frees = 0;
+ pool->peak_usage = pool->current_usage;
+
+ AI_LOGI("Statistics reset for pool %s", g_pool_type_names[pool_type]);
+}
+
+/**
+ * @brief 内存池碎片整理
+ */
+ai_error_t ai_memory_pool_defragment(ai_pool_type_t pool_type)
+{
+ if (!g_pool_initialized) {
+ AI_LOGE("Memory pool not initialized");
+ return AI_ERROR_NOT_INITIALIZED;
+ }
+
+ if (pool_type >= AI_POOL_TYPE_COUNT) {
+ AI_LOGE("Invalid pool type: %d", pool_type);
+ return AI_ERROR_INVALID_PARAM;
+ }
+
+ ai_memory_pool_t *pool = &g_pool_manager.pools[pool_type];
+
+#ifndef __TEST_MODE__
+ if (osMutexAcquire(pool->mutex, osWaitForever) != osOK) {
+ AI_LOGE("Failed to acquire pool mutex");
+ return AI_ERROR_MUTEX_FAILED;
+ }
+#endif
+
+ AI_LOGI("Starting defragmentation for pool %s", g_pool_type_names[pool_type]);
+
+ // 简单的碎片整理：重新组织空闲块链表
+ ai_memory_block_t *current = pool->free_list;
+ ai_memory_block_t *prev = NULL;
+ uint16_t merged_count = 0;
+
+ while (current != NULL && current->next != NULL) {
+ ai_memory_block_t *next = current->next;
+
+ // 检查是否可以合并相邻的空闲块
+ if ((uint8_t*)current->data + current->size == (uint8_t*)next->data) {
+ // 合并块
+ current->size += next->size;
+ current->next = next->next;
+ if (next->next != NULL) {
+ next->next->prev = current;
+ }
+
+ // 重置被合并的块
+ next->state = AI_BUFFER_STATE_FREE;
+ next->owner_service = AI_SERVICE_COUNT;
+ next->used = 0;
+ next->next = NULL;
+ next->prev = NULL;
+
+ merged_count++;
+ AI_LOGI("Merged adjacent blocks, new size: %u", current->size);
+ } else {
+ prev = current;
+ current = current->next;
+ }
+ }
+
+ // 更新碎片率
+ if (pool->free_count > 0) {
+ uint8_t old_fragmentation = pool->fragmentation_level;
+ pool->fragmentation_level = (uint8_t)((merged_count * 100) / pool->free_count);
+
+ if (pool->fragmentation_level < old_fragmentation) {
+ AI_LOGI("Fragmentation reduced from %u%% to %u%%",
+ old_fragmentation, pool->fragmentation_level);
+ }
+ }
+
+#ifndef __TEST_MODE__
+ osMutexRelease(pool->mutex);
+#endif
+
+ AI_LOGI("Defragmentation completed for pool %s, merged %u blocks",
+ g_pool_type_names[pool_type], merged_count);
+
+ return AI_OK;
+}
\ No newline at end of file
+++ /dev/null
-/*
- * AI服务通用功能实现
- * 提供ASR、TTS、Chat服务的通用基础功能
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <time.h>
-#include <sys/time.h>
-#include "ai_service_common.h"
-#include "../../../../application/wearable/ohos_deps/wearable_log.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* 内部宏定义 */
-#define AI_SERVICE_LOG_TAG "AI_SERVICE"
-#define AI_SERVICE_THREAD_STACK_SIZE 8192
-#define AI_SERVICE_HEARTBEAT_STACK_SIZE 4096
-
-/* WebSocket回调函数声明 */
-static void ai_service_on_open(int client);
-static void ai_service_on_message(int client, const char *data, size_t length, bool isFinished);
-static void ai_service_on_error(int client, struct WebSocketErrorResult errorResult);
-static void ai_service_on_close(int client);
-
-/* 内部函数声明 */
-static void ai_service_main_thread(void *arg);
-static void ai_service_heartbeat_thread(void *arg);
-static void ai_service_reconnect_timer_callback(void *arg);
-static void ai_service_heartbeat_timer_callback(void *arg);
-static ai_service_error_t ai_service_internal_connect(ai_service_context_t *context);
-static ai_service_error_t ai_service_internal_disconnect(ai_service_context_t *context);
-static void ai_service_update_stats_on_connect(ai_service_context_t *context);
-static void ai_service_update_stats_on_disconnect(ai_service_context_t *context);
-static void ai_service_update_stats_on_send(ai_service_context_t *context, size_t bytes);
-static void ai_service_update_stats_on_receive(ai_service_context_t *context, size_t bytes);
-static void ai_service_update_stats_on_error(ai_service_context_t *context);
-
-/* 全局上下文映射表（用于WebSocket回调） */
-#define AI_SERVICE_MAX_CONTEXTS 10
-static ai_service_context_t *g_context_map[AI_SERVICE_MAX_CONTEXTS] = {NULL};
-static osMutexId_t g_context_map_mutex = NULL;
-
-/* 初始化全局资源 */
-static ai_service_error_t ai_service_init_global_resources(void)
-{
- if (g_context_map_mutex == NULL) {
- g_context_map_mutex = osMutexNew(NULL);
- if (g_context_map_mutex == NULL) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Failed to create global mutex", AI_SERVICE_LOG_TAG);
- return AI_SERVICE_ERROR_INTERNAL;
- }
- }
- return AI_SERVICE_OK;
-}
-
-/* 注册上下文到全局映射表 */
-static ai_service_error_t ai_service_register_context(ai_service_context_t *context)
-{
- if (ai_service_init_global_resources() != AI_SERVICE_OK) {
- return AI_SERVICE_ERROR_INTERNAL;
- }
-
- osMutexAcquire(g_context_map_mutex, osWaitForever);
-
- for (int i = 0; i < AI_SERVICE_MAX_CONTEXTS; i++) {
- if (g_context_map[i] == NULL) {
- g_context_map[i] = context;
- context->ws_client_fd = i; // 使用索引作为临时客户端ID
- osMutexRelease(g_context_map_mutex);
- return AI_SERVICE_OK;
- }
- }
-
- osMutexRelease(g_context_map_mutex);
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Context map is full", AI_SERVICE_LOG_TAG);
- return AI_SERVICE_ERROR_INTERNAL;
-}
-
-/* 从全局映射表注销上下文 */
-static void ai_service_unregister_context(ai_service_context_t *context)
-{
- if (g_context_map_mutex == NULL) return;
-
- osMutexAcquire(g_context_map_mutex, osWaitForever);
-
- for (int i = 0; i < AI_SERVICE_MAX_CONTEXTS; i++) {
- if (g_context_map[i] == context) {
- g_context_map[i] = NULL;
- break;
- }
- }
-
- osMutexRelease(g_context_map_mutex);
-}
-
-/* 根据客户端ID获取上下文 */
-static ai_service_context_t* ai_service_get_context_by_client(int client)
-{
- if (g_context_map_mutex == NULL || client < 0 || client >= AI_SERVICE_MAX_CONTEXTS) {
- return NULL;
- }
-
- osMutexAcquire(g_context_map_mutex, osWaitForever);
- ai_service_context_t *context = g_context_map[client];
- osMutexRelease(g_context_map_mutex);
-
- return context;
-}
-
-/* 公共接口实现 */
-
-ai_service_error_t ai_service_init(ai_service_context_t *context,
- const char *service_name,
- const ai_service_config_t *config)
-{
- if (!context || !service_name || !config) {
- return AI_SERVICE_ERROR_INVALID_PARAM;
- }
-
- // 清零上下文
- memset(context, 0, sizeof(ai_service_context_t));
-
- // 复制服务名称
- strncpy(context->service_name, service_name, sizeof(context->service_name) - 1);
-
- // 复制配置
- memcpy(&context->config, config, sizeof(ai_service_config_t));
-
- // 初始化状态
- context->state = AI_SERVICE_STATE_IDLE;
- context->is_connected = false;
- context->retry_count = 0;
- context->ws_client_fd = -1;
-
- // 创建互斥锁
- context->mutex = osMutexNew(NULL);
- if (context->mutex == NULL) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Failed to create mutex for %s",
- AI_SERVICE_LOG_TAG, service_name);
- return AI_SERVICE_ERROR_INTERNAL;
- }
-
- // 创建连接信号量
- context->connect_sem = osSemaphoreNew(1, 0, NULL);
- if (context->connect_sem == NULL) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Failed to create semaphore for %s",
- AI_SERVICE_LOG_TAG, service_name);
- osMutexDelete(context->mutex);
- return AI_SERVICE_ERROR_INTERNAL;
- }
-
- // 注册到全局映射表
- ai_service_error_t ret = ai_service_register_context(context);
- if (ret != AI_SERVICE_OK) {
- osSemaphoreDelete(context->connect_sem);
- osMutexDelete(context->mutex);
- return ret;
- }
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Service %s initialized",
- AI_SERVICE_LOG_TAG, service_name);
-
- return AI_SERVICE_OK;
-}
-
-ai_service_error_t ai_service_destroy(ai_service_context_t *context)
-{
- if (!context) {
- return AI_SERVICE_ERROR_INVALID_PARAM;
- }
-
- // 停止服务
- ai_service_stop(context);
-
- // 从全局映射表注销
- ai_service_unregister_context(context);
-
- // 删除定时器
- if (context->reconnect_timer) {
- osTimerDelete(context->reconnect_timer);
- context->reconnect_timer = NULL;
- }
-
- if (context->heartbeat_timer) {
- osTimerDelete(context->heartbeat_timer);
- context->heartbeat_timer = NULL;
- }
-
- // 删除同步对象
- if (context->connect_sem) {
- osSemaphoreDelete(context->connect_sem);
- context->connect_sem = NULL;
- }
-
- if (context->mutex) {
- osMutexDelete(context->mutex);
- context->mutex = NULL;
- }
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Service %s destroyed",
- AI_SERVICE_LOG_TAG, context->service_name);
-
- return AI_SERVICE_OK;
-}
-
-ai_service_error_t ai_service_start(ai_service_context_t *context)
-{
- if (!context) {
- return AI_SERVICE_ERROR_INVALID_PARAM;
- }
-
- osMutexAcquire(context->mutex, osWaitForever);
-
- if (context->state != AI_SERVICE_STATE_IDLE) {
- osMutexRelease(context->mutex);
- WEARABLE_LOGW(WEARABLE_LOG_MODULE_APP, "[%s] Service %s is not in idle state",
- AI_SERVICE_LOG_TAG, context->service_name);
- return AI_SERVICE_ERROR_ALREADY_CONNECTED;
- }
-
- // 创建重连定时器
- context->reconnect_timer = osTimerNew(ai_service_reconnect_timer_callback, osTimerOnce, context, NULL);
- if (context->reconnect_timer == NULL) {
- osMutexRelease(context->mutex);
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Failed to create reconnect timer for %s",
- AI_SERVICE_LOG_TAG, context->service_name);
- return AI_SERVICE_ERROR_INTERNAL;
- }
-
- // 创建心跳定时器
- context->heartbeat_timer = osTimerNew(ai_service_heartbeat_timer_callback, osTimerPeriodic, context, NULL);
- if (context->heartbeat_timer == NULL) {
- osTimerDelete(context->reconnect_timer);
- context->reconnect_timer = NULL;
- osMutexRelease(context->mutex);
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Failed to create heartbeat timer for %s",
- AI_SERVICE_LOG_TAG, context->service_name);
- return AI_SERVICE_ERROR_INTERNAL;
- }
-
- // 创建主线程
- osThreadAttr_t thread_attr = {0};
- thread_attr.name = context->service_name;
- thread_attr.stack_size = AI_SERVICE_THREAD_STACK_SIZE;
- thread_attr.priority = osPriorityNormal;
- // void* p = aligned_alloc(16,AI_SERVICE_THREAD_STACK_SIZE);
- // 使用memalign分配栈内存
- void* p = memalign(16,AI_SERVICE_THREAD_STACK_SIZE);
- if(p==NULL)
- {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Failed to aligned alloc for %s",
- AI_SERVICE_LOG_TAG, context->service_name);
- return AI_SERVICE_ERROR_INTERNAL;
- }
- thread_attr.stack_mem = p;
-
- context->service_thread = osThreadNew(ai_service_main_thread, context, &thread_attr);
- if (context->service_thread == NULL) {
- osTimerDelete(context->heartbeat_timer);
- osTimerDelete(context->reconnect_timer);
- context->heartbeat_timer = NULL;
- context->reconnect_timer = NULL;
- osMutexRelease(context->mutex);
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Failed to create main thread for %s",
- AI_SERVICE_LOG_TAG, context->service_name);
- return AI_SERVICE_ERROR_INTERNAL;
- }
-
- context->state = AI_SERVICE_STATE_CONNECTING;
- osMutexRelease(context->mutex);
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Service %s started",
- AI_SERVICE_LOG_TAG, context->service_name);
-
- return AI_SERVICE_OK;
-}
-
-ai_service_error_t ai_service_stop(ai_service_context_t *context)
-{
- if (!context) {
- return AI_SERVICE_ERROR_INVALID_PARAM;
- }
-
- osMutexAcquire(context->mutex, osWaitForever);
-
- if (context->state == AI_SERVICE_STATE_IDLE) {
- osMutexRelease(context->mutex);
- return AI_SERVICE_OK;
- }
-
- context->state = AI_SERVICE_STATE_IDLE;
- osMutexRelease(context->mutex);
-
- // 断开连接
- ai_service_internal_disconnect(context);
-
- // 停止定时器
- if (context->reconnect_timer) {
- osTimerStop(context->reconnect_timer);
- }
-
- if (context->heartbeat_timer) {
- osTimerStop(context->heartbeat_timer);
- }
-
- // 等待线程结束
- if (context->service_thread) {
- osThreadTerminate(context->service_thread);
- context->service_thread = NULL;
- }
-
- if (context->heartbeat_thread) {
- osThreadTerminate(context->heartbeat_thread);
- context->heartbeat_thread = NULL;
- }
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Service %s stopped",
- AI_SERVICE_LOG_TAG, context->service_name);
-
- return AI_SERVICE_OK;
-}
-
-ai_service_error_t ai_service_connect(ai_service_context_t *context)
-{
- if (!context) {
- return AI_SERVICE_ERROR_INVALID_PARAM;
- }
-
- return ai_service_internal_connect(context);
-}
-
-ai_service_error_t ai_service_disconnect(ai_service_context_t *context)
-{
- if (!context) {
- return AI_SERVICE_ERROR_INVALID_PARAM;
- }
-
- return ai_service_internal_disconnect(context);
-}
-
-ai_service_error_t ai_service_send_data(ai_service_context_t *context,
- const char *data, size_t length)
-{
- if (!context || !data || length == 0) {
- return AI_SERVICE_ERROR_INVALID_PARAM;
- }
-
- if (!context->is_connected || context->ws_client_fd < 0) {
- WEARABLE_LOGW(WEARABLE_LOG_MODULE_APP, "[%s] Service %s is not connected",
- AI_SERVICE_LOG_TAG, context->service_name);
- return AI_SERVICE_ERROR_NOT_CONNECTED;
- }
-
- int ret = WebSocketClientSendBinStart(context->ws_client_fd, data, length);
- if (ret != WEBSOCKET_OK) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Failed to send data for %s: %d",
- AI_SERVICE_LOG_TAG, context->service_name, ret);
- ai_service_update_stats_on_error(context);
- return AI_SERVICE_ERROR_NETWORK;
- }
-
- ai_service_update_stats_on_send(context, length);
-
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[%s] Sent %zu bytes for %s",
- AI_SERVICE_LOG_TAG, length, context->service_name);
-
- return AI_SERVICE_OK;
-}
-
-ai_service_error_t ai_service_send_text(ai_service_context_t *context, const char *text)
-{
- if (!context || !text) {
- return AI_SERVICE_ERROR_INVALID_PARAM;
- }
-
- if (!context->is_connected || context->ws_client_fd < 0) {
- WEARABLE_LOGW(WEARABLE_LOG_MODULE_APP, "[%s] Service %s is not connected",
- AI_SERVICE_LOG_TAG, context->service_name);
- return AI_SERVICE_ERROR_NOT_CONNECTED;
- }
-
- size_t length = strlen(text);
- int ret = WebSocketClientSendText(context->ws_client_fd, text, length);
- if (ret != WEBSOCKET_OK) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Failed to send text for %s: %d",
- AI_SERVICE_LOG_TAG, context->service_name, ret);
- ai_service_update_stats_on_error(context);
- return AI_SERVICE_ERROR_NETWORK;
- }
-
- ai_service_update_stats_on_send(context, length);
-
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[%s] Sent text (%zu chars) for %s",
- AI_SERVICE_LOG_TAG, length, context->service_name);
-
- return AI_SERVICE_OK;
-}
-
-ai_service_error_t ai_service_send_binary(ai_service_context_t *context,
- const char *data, size_t length)
-{
- return ai_service_send_data(context, data, length);
-}
-
-bool ai_service_is_connected(ai_service_context_t *context)
-{
- if (!context) {
- return false;
- }
-
- return context->is_connected && (context->ws_client_fd >= 0) &&
- WebSocketClientIsConnected(context->ws_client_fd);
-}
-
-ai_service_state_t ai_service_get_state(ai_service_context_t *context)
-{
- if (!context) {
- return AI_SERVICE_STATE_ERROR;
- }
-
- return context->state;
-}
-
-const ai_service_stats_t* ai_service_get_stats(ai_service_context_t *context)
-{
- if (!context) {
- return NULL;
- }
-
- return &context->stats;
-}
-
-void ai_service_set_callbacks(ai_service_context_t *context,
- void (*on_connected)(void *context),
- void (*on_disconnected)(void *context),
- void (*on_message_received)(void *context, const char *data, size_t length),
- void (*on_error)(void *context, int error_code, const char *error_msg))
-{
- if (!context) {
- return;
- }
-
- context->on_connected = on_connected;
- context->on_disconnected = on_disconnected;
- context->on_message_received = on_message_received;
- context->on_error = on_error;
-}
-
-void ai_service_set_user_data(ai_service_context_t *context, void *user_data)
-{
- if (context) {
- context->user_data = user_data;
- }
-}
-
-void* ai_service_get_user_data(ai_service_context_t *context)
-{
- return context ? context->user_data : NULL;
-}
-
-/* 工具函数实现 */
-
-uint32_t ai_service_get_timestamp(void)
-{
- struct timeval tv;
- gettimeofday(&tv, NULL);
- return (uint32_t)(tv.tv_sec * 1000 + tv.tv_usec / 1000);
-}
-
-ai_service_error_t ai_service_generate_uuid(char *uuid_str, size_t max_len)
-{
- if (!uuid_str || max_len < 37) {
- return AI_SERVICE_ERROR_INVALID_PARAM;
- }
-
- // 简单的UUID生成（基于时间戳和随机数）
- uint32_t timestamp = ai_service_get_timestamp();
- uint32_t random1 = rand();
- uint32_t random2 = rand();
-
- snprintf(uuid_str, max_len, "%08x-%04x-%04x-%04x-%08x%04x",
- timestamp,
- (random1 >> 16) & 0xFFFF,
- random1 & 0xFFFF,
- (random2 >> 16) & 0xFFFF,
- random2,
- timestamp & 0xFFFF);
-
- return AI_SERVICE_OK;
-}
-
-ai_service_error_t ai_service_create_json_message(const char *type,
- const char *data,
- char *output,
- size_t max_len)
-{
- if (!type || !data || !output || max_len == 0) {
- return AI_SERVICE_ERROR_INVALID_PARAM;
- }
-
- char uuid[64];
- ai_service_generate_uuid(uuid, sizeof(uuid));
- uint32_t timestamp = ai_service_get_timestamp();
-
- int ret = snprintf(output, max_len,
- "{"
- "\"id\":\"%s\","
- "\"type\":\"%s\","
- "\"timestamp\":%u,"
- "\"data\":\"%s\""
- "}",
- uuid, type, timestamp, data);
-
- if (ret >= (int)max_len) {
- return AI_SERVICE_ERROR_INVALID_PARAM; // 缓冲区太小
- }
-
- return AI_SERVICE_OK;
-}
-
-/* 内部函数实现 */
-
-static ai_service_error_t ai_service_internal_connect(ai_service_context_t *context)
-{
- if (context->is_connected) {
- return AI_SERVICE_OK;
- }
-
- // 创建WebSocket客户端
- int client_fd = WebSocketClientConstructor(ai_service_on_open, ai_service_on_message,
- ai_service_on_error, ai_service_on_close);
- if (client_fd < 0) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Failed to create WebSocket client for %s",
- AI_SERVICE_LOG_TAG, context->service_name);
- return AI_SERVICE_ERROR_NETWORK;
- }
-
- // 设置协议
- if (strlen(context->config.protocol) > 0) {
- WebSocketClientSetProtocol(client_fd, context->config.protocol);
- }
-
- // 连接到服务器
- int ret = WebSocketClientConnect(client_fd, context->config.server_url);
- if (ret != WEBSOCKET_OK) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Failed to connect to %s: %d",
- AI_SERVICE_LOG_TAG, context->config.server_url, ret);
- WebSocketClientClose(client_fd);
- return AI_SERVICE_ERROR_NETWORK;
- }
-
- context->ws_client_fd = client_fd;
-
- // 等待连接成功
- osStatus_t status = osSemaphoreAcquire(context->connect_sem, context->config.connect_timeout_ms);
- if (status != osOK) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Connection timeout for %s",
- AI_SERVICE_LOG_TAG, context->service_name);
- WebSocketClientClose(client_fd);
- context->ws_client_fd = -1;
- return AI_SERVICE_ERROR_TIMEOUT;
- }
-
- if (!context->is_connected) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Connection failed for %s",
- AI_SERVICE_LOG_TAG, context->service_name);
- return AI_SERVICE_ERROR_NETWORK;
- }
-
- // 启动心跳定时器
- if (context->config.heartbeat_interval_ms > 0) {
- osTimerStart(context->heartbeat_timer, context->config.heartbeat_interval_ms);
- }
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Connected to %s",
- AI_SERVICE_LOG_TAG, context->config.server_url);
-
- return AI_SERVICE_OK;
-}
-
-static ai_service_error_t ai_service_internal_disconnect(ai_service_context_t *context)
-{
- if (!context->is_connected) {
- return AI_SERVICE_OK;
- }
-
- // 停止心跳定时器
- if (context->heartbeat_timer) {
- osTimerStop(context->heartbeat_timer);
- }
-
- // 关闭WebSocket连接
- if (context->ws_client_fd >= 0) {
- WebSocketClientClose(context->ws_client_fd);
- context->ws_client_fd = -1;
- }
-
- context->is_connected = false;
- ai_service_update_stats_on_disconnect(context);
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Disconnected from %s",
- AI_SERVICE_LOG_TAG, context->service_name);
-
- return AI_SERVICE_OK;
-}
-
-/* WebSocket回调函数实现 */
-
-static void ai_service_on_open(int client)
-{
- ai_service_context_t *context = ai_service_get_context_by_client(client);
- if (!context) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Invalid client %d in on_open",
- AI_SERVICE_LOG_TAG, client);
- return;
- }
-
- context->is_connected = true;
- context->state = AI_SERVICE_STATE_CONNECTED;
- context->retry_count = 0;
-
- ai_service_update_stats_on_connect(context);
-
- // 释放连接信号量
- osSemaphoreRelease(context->connect_sem);
-
- // 调用用户回调
- if (context->on_connected) {
- context->on_connected(context);
- }
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Service %s connected",
- AI_SERVICE_LOG_TAG, context->service_name);
-}
-
-static void ai_service_on_message(int client, const char *data, size_t length, bool isFinished)
-{
- ai_service_context_t *context = ai_service_get_context_by_client(client);
- if (!context) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Invalid client %d in on_message",
- AI_SERVICE_LOG_TAG, client);
- return;
- }
-
- ai_service_update_stats_on_receive(context, length);
-
- // 调用用户回调
- if (context->on_message_received) {
- context->on_message_received(context, data, length);
- }
-
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[%s] Service %s received %zu bytes",
- AI_SERVICE_LOG_TAG, context->service_name, length);
-}
-
-static void ai_service_on_error(int client, struct WebSocketErrorResult errorResult)
-{
- ai_service_context_t *context = ai_service_get_context_by_client(client);
- if (!context) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Invalid client %d in on_error",
- AI_SERVICE_LOG_TAG, client);
- return;
- }
-
- context->state = AI_SERVICE_STATE_ERROR;
- ai_service_update_stats_on_error(context);
-
- // 调用用户回调
- if (context->on_error) {
- context->on_error(context, errorResult.errorCode, errorResult.errorMessage);
- }
-
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Service %s error: %d - %s",
- AI_SERVICE_LOG_TAG, context->service_name,
- errorResult.errorCode, errorResult.errorMessage);
-
- // 触发重连
- if (context->config.auto_reconnect && context->retry_count < context->config.max_retry_count) {
- context->state = AI_SERVICE_STATE_RECONNECTING;
- osTimerStart(context->reconnect_timer, context->config.reconnect_interval_ms);
- }
-}
-
-static void ai_service_on_close(int client)
-{
- ai_service_context_t *context = ai_service_get_context_by_client(client);
- if (!context) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Invalid client %d in on_close",
- AI_SERVICE_LOG_TAG, client);
- return;
- }
-
- context->is_connected = false;
- context->state = AI_SERVICE_STATE_DISCONNECTED;
- context->ws_client_fd = -1;
-
- ai_service_update_stats_on_disconnect(context);
-
- // 停止心跳定时器
- if (context->heartbeat_timer) {
- osTimerStop(context->heartbeat_timer);
- }
-
- // 调用用户回调
- if (context->on_disconnected) {
- context->on_disconnected(context);
- }
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Service %s closed",
- AI_SERVICE_LOG_TAG, context->service_name);
-
- // 触发重连
- if (context->config.auto_reconnect && context->retry_count < context->config.max_retry_count) {
- context->state = AI_SERVICE_STATE_RECONNECTING;
- osTimerStart(context->reconnect_timer, context->config.reconnect_interval_ms);
- }
-}
-
-/* 线程函数实现 */
-
-static void ai_service_main_thread(void *arg)
-{
- ai_service_context_t *context = (ai_service_context_t *)arg;
- if (!context) {
- return;
- }
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Main thread started for %s",
- AI_SERVICE_LOG_TAG, context->service_name);
-
- // 初始连接
- ai_service_internal_connect(context);
-
- // 主循环
- while (context->state != AI_SERVICE_STATE_IDLE) {
- osDelay(1000); // 1秒检查一次
-
- // 检查连接状态
- if (context->is_connected && !WebSocketClientIsConnected(context->ws_client_fd)) {
- WEARABLE_LOGW(WEARABLE_LOG_MODULE_APP, "[%s] Connection lost for %s",
- AI_SERVICE_LOG_TAG, context->service_name);
- context->is_connected = false;
- context->state = AI_SERVICE_STATE_DISCONNECTED;
-
- // 触发重连
- if (context->config.auto_reconnect && context->retry_count < context->config.max_retry_count) {
- context->state = AI_SERVICE_STATE_RECONNECTING;
- osTimerStart(context->reconnect_timer, context->config.reconnect_interval_ms);
- }
- }
- }
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Main thread stopped for %s",
- AI_SERVICE_LOG_TAG, context->service_name);
-}
-
-static void ai_service_heartbeat_thread(void *arg)
-{
- ai_service_context_t *context = (ai_service_context_t *)arg;
- if (!context) {
- return;
- }
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Heartbeat thread started for %s",
- AI_SERVICE_LOG_TAG, context->service_name);
-
- while (context->state != AI_SERVICE_STATE_IDLE) {
- osDelay(context->config.heartbeat_interval_ms);
-
- if (context->is_connected) {
- // 发送心跳消息
- const char *heartbeat = "{\"type\":\"heartbeat\"}";
- ai_service_send_text(context, heartbeat);
- }
- }
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Heartbeat thread stopped for %s",
- AI_SERVICE_LOG_TAG, context->service_name);
-}
-
-/* 定时器回调函数实现 */
-
-static void ai_service_reconnect_timer_callback(void *arg)
-{
- ai_service_context_t *context = (ai_service_context_t *)arg;
- if (!context) {
- return;
- }
-
- if (context->state != AI_SERVICE_STATE_RECONNECTING) {
- return;
- }
-
- context->retry_count++;
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Attempting reconnection %d/%d for %s",
- AI_SERVICE_LOG_TAG, context->retry_count,
- context->config.max_retry_count, context->service_name);
-
- ai_service_error_t ret = ai_service_internal_connect(context);
- if (ret != AI_SERVICE_OK) {
- if (context->retry_count < context->config.max_retry_count) {
- // 继续重试
- osTimerStart(context->reconnect_timer, context->config.reconnect_interval_ms);
- } else {
- // 重试次数用完
- context->state = AI_SERVICE_STATE_ERROR;
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Max retry count reached for %s",
- AI_SERVICE_LOG_TAG, context->service_name);
- }
- }
-}
-
-static void ai_service_heartbeat_timer_callback(void *arg)
-{
- ai_service_context_t *context = (ai_service_context_t *)arg;
- if (!context) {
- return;
- }
-
- if (context->is_connected) {
- // 发送心跳消息
- const char *heartbeat = "{\"type\":\"heartbeat\"}";
- ai_service_send_text(context, heartbeat);
- }
-}
-
-/* 统计信息更新函数 */
-
-static void ai_service_update_stats_on_connect(ai_service_context_t *context)
-{
- context->stats.connect_count++;
- context->stats.last_connect_time = ai_service_get_timestamp();
-}
-
-static void ai_service_update_stats_on_disconnect(ai_service_context_t *context)
-{
- context->stats.disconnect_count++;
- context->stats.last_disconnect_time = ai_service_get_timestamp();
-}
-
-static void ai_service_update_stats_on_send(ai_service_context_t *context, size_t bytes)
-{
- context->stats.send_count++;
- context->stats.total_bytes_sent += bytes;
-}
-
-static void ai_service_update_stats_on_receive(ai_service_context_t *context, size_t bytes)
-{
- context->stats.receive_count++;
- context->stats.total_bytes_received += bytes;
-}
-
-static void ai_service_update_stats_on_error(ai_service_context_t *context)
-{
- context->stats.error_count++;
-}
-
-
-
-/**
- * @brief 判断字符串是否为JSON语句（20字节内，首个非空字符为'{'，且下一个非空字符为'"'）
- * @param str 字符串指针
- * @param len 字符串长度
- * @return 如果字符串为JSON对象（{...}），返回true，否则返回false
- */
-bool ai_service_is_json_string(const char *str, size_t len)
-{
- if (!str || len == 0) return false;
- size_t max_check = len < 20 ? len : 20;
- size_t i = 0;
-
- // 跳过前导空白
- while (i < max_check && (str[i] == ' ' || str[i] == '\t' || str[i] == '\n' || str[i] == '\r')) {
- i++;
- }
- // 检查第一个非空字符是否为'{'
- if (i < max_check && str[i] == '{') {
- i++;
- // 跳过'{'后面的空白
- while (i < max_check && (str[i] == ' ' || str[i] == '\t' || str[i] == '\n' || str[i] == '\r')) {
- i++;
- }
- // 检查下一个非空字符是否为'"'
- if (i < max_check && str[i] == '"') {
- return true;
- }
- }
- return false;
-}
-
-
-
-
-
-#ifdef __cplusplus
-}
-#endif
\ No newline at end of file
+++ /dev/null
-/*
- * Copyright (c) CompanyNameMagicTag. 2023-2023. All rights reserved.
- * Description: AI Service Manager Implementation - AI全家桶实现
- * Author: AI Development Team
- * Create: 2024-12-28
- */
-
-#include "ai_service_manager.h"
-#include "../../../../application/wearable/ohos_deps/wearable_log.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <time.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* ==================== 内部宏定义 ==================== */
-
-#define AI_MANAGER_LOG_TAG "AI_MANAGER"
-#define AI_MANAGER_THREAD_STACK_SIZE 16384
-#define AI_MANAGER_EVENT_QUEUE_SIZE 32
-#define AI_MANAGER_RESPONSE_TIMEOUT_MS 30000
-
-/* ==================== 内部函数声明 ==================== */
-
-static void ai_manager_main_thread(void *arg);
-static ai_service_error_t ai_manager_init_services(ai_manager_context_t *context);
-static ai_service_error_t ai_manager_deinit_services(ai_manager_context_t *context);
-static void ai_manager_set_state(ai_manager_context_t *context, ai_manager_state_t new_state);
-static void ai_manager_handle_asr_event(ai_manager_context_t *context, const asr_recognition_result_t *result);
-static void ai_manager_handle_chat_event(ai_manager_context_t *context, const chat_response_t *response);
-static void ai_manager_handle_tts_event(ai_manager_context_t *context, const tts_synthesis_result_t *result);
-static void ai_manager_send_event(ai_manager_context_t *context, const ai_event_data_t *event);
-static uint32_t ai_manager_get_timestamp(void);
-
-/* ASR回调函数 */
-static void ai_manager_asr_on_result(void *user_data, const asr_recognition_result_t *result);
-static void ai_manager_asr_on_error(void *user_data, int error_code, const char *error_msg);
-
-/* Chat回调函数 */
-static void ai_manager_chat_on_response(void *user_data, const chat_response_t *response);
-static void ai_manager_chat_on_error(void *user_data, int error_code, const char *error_msg);
-
-/* TTS回调函数 */
-static void ai_manager_tts_on_result(void *user_data, const tts_synthesis_result_t *result);
-static void ai_manager_tts_on_error(void *user_data, int error_code, const char *error_msg);
-
-/* 录音回调函数 */
-static void ai_manager_record_callback(uint8_t *data, uint32_t size);
-
-/* ==================== 全局变量 ==================== */
-
-static ai_manager_context_t *g_current_manager = NULL; // 当前管理器实例（用于录音回调）
-
-/* ==================== 公共接口实现 ==================== */
-
-ai_service_error_t ai_manager_init(ai_manager_context_t *context,
- const ai_manager_config_t *config)
-{
- if (context == NULL || config == NULL) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Invalid parameters", AI_MANAGER_LOG_TAG);
- return AI_SERVICE_ERROR_INVALID_PARAM;
- }
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Initializing AI Manager", AI_MANAGER_LOG_TAG);
-
- // 清零上下文
- memset(context, 0, sizeof(ai_manager_context_t));
-
- // 复制配置
- memcpy(&context->config, config, sizeof(ai_manager_config_t));
-
- // 设置初始状态
- context->state = AI_MANAGER_STATE_INITIALIZING;
- context->init_timestamp = ai_manager_get_timestamp();
-
- // 生成初始会话ID
- ai_manager_generate_session_id(context->current_session_id,
- sizeof(context->current_session_id));
-
- // 创建互斥锁
- context->mutex = osMutexNew(NULL);
- if (context->mutex == NULL) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Failed to create mutex", AI_MANAGER_LOG_TAG);
- return AI_SERVICE_ERROR_INTERNAL;
- }
-
- // 创建事件队列
- context->event_queue = osMessageQueueNew(AI_MANAGER_EVENT_QUEUE_SIZE,
- sizeof(ai_event_data_t), NULL);
- if (context->event_queue == NULL) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Failed to create event queue", AI_MANAGER_LOG_TAG);
- osMutexDelete(context->mutex);
- return AI_SERVICE_ERROR_INTERNAL;
- }
-
- // 初始化AI媒体服务
- if (ai_media_service_init() != 0) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Failed to init AI media service", AI_MANAGER_LOG_TAG);
- osMessageQueueDelete(context->event_queue);
- osMutexDelete(context->mutex);
- return AI_SERVICE_ERROR_INTERNAL;
- }
-
- // 设置录音回调
- g_current_manager = context;
- ai_media_set_record_callback(ai_manager_record_callback);
-
- // 初始化各个AI服务
- ai_service_error_t ret = ai_manager_init_services(context);
- if (ret != AI_SERVICE_OK) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Failed to init AI services", AI_MANAGER_LOG_TAG);
- ai_media_service_deinit();
- osMessageQueueDelete(context->event_queue);
- osMutexDelete(context->mutex);
- return ret;
- }
-
- // 创建主线程
- osThreadAttr_t thread_attr = {
- .name = "ai_manager",
- .stack_size = AI_MANAGER_THREAD_STACK_SIZE,
- .priority = osPriorityNormal
- };
-
- context->manager_thread = osThreadNew(ai_manager_main_thread, context, &thread_attr);
- if (context->manager_thread == NULL) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Failed to create main thread", AI_MANAGER_LOG_TAG);
- ai_manager_deinit_services(context);
- ai_media_service_deinit();
- osMessageQueueDelete(context->event_queue);
- osMutexDelete(context->mutex);
- return AI_SERVICE_ERROR_INTERNAL;
- }
-
- context->services_initialized = true;
- ai_manager_set_state(context, AI_MANAGER_STATE_IDLE);
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] AI Manager initialized successfully", AI_MANAGER_LOG_TAG);
- return AI_SERVICE_OK;
-}
-
-ai_service_error_t ai_manager_destroy(ai_manager_context_t *context)
-{
- if (context == NULL) {
- return AI_SERVICE_ERROR_INVALID_PARAM;
- }
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Destroying AI Manager", AI_MANAGER_LOG_TAG);
-
- ai_manager_set_state(context, AI_MANAGER_STATE_SHUTDOWN);
-
- // 停止所有服务
- ai_manager_stop(context);
-
- // 终止主线程
- if (context->manager_thread != NULL) {
- osThreadTerminate(context->manager_thread);
- context->manager_thread = NULL;
- }
-
- // 反初始化服务
- ai_manager_deinit_services(context);
-
- // 反初始化媒体服务
- ai_media_service_deinit();
-
- // 清理资源
- if (context->event_queue != NULL) {
- osMessageQueueDelete(context->event_queue);
- context->event_queue = NULL;
- }
-
- if (context->mutex != NULL) {
- osMutexDelete(context->mutex);
- context->mutex = NULL;
- }
-
- // 清空全局引用
- if (g_current_manager == context) {
- g_current_manager = NULL;
- }
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] AI Manager destroyed", AI_MANAGER_LOG_TAG);
- return AI_SERVICE_OK;
-}
-
-ai_service_error_t ai_manager_start(ai_manager_context_t *context)
-{
- if (context == NULL) {
- return AI_SERVICE_ERROR_INVALID_PARAM;
- }
-
- osMutexAcquire(context->mutex, osWaitForever);
-
- if (context->state != AI_MANAGER_STATE_IDLE) {
- osMutexRelease(context->mutex);
- WEARABLE_LOGW(WEARABLE_LOG_MODULE_APP, "[%s] Manager not in idle state", AI_MANAGER_LOG_TAG);
- return AI_SERVICE_ERROR_INVALID_PARAM;
- }
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Starting AI services", AI_MANAGER_LOG_TAG);
-
- // 启动ASR服务
- if (asr_server_start(context->asr_context) != AI_SERVICE_OK) {
- osMutexRelease(context->mutex);
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Failed to start ASR service", AI_MANAGER_LOG_TAG);
- return AI_SERVICE_ERROR_INTERNAL;
- }
-
- // 启动Chat服务
- if (chat_server_start(context->chat_context) != AI_SERVICE_OK) {
- asr_server_stop(context->asr_context);
- osMutexRelease(context->mutex);
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Failed to start Chat service", AI_MANAGER_LOG_TAG);
- return AI_SERVICE_ERROR_INTERNAL;
- }
-
- // 启动TTS服务
- if (tts_server_start(context->tts_context) != AI_SERVICE_OK) {
- chat_server_stop(context->chat_context);
- asr_server_stop(context->asr_context);
- osMutexRelease(context->mutex);
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Failed to start TTS service", AI_MANAGER_LOG_TAG);
- return AI_SERVICE_ERROR_INTERNAL;
- }
-
- ai_manager_set_state(context, AI_MANAGER_STATE_READY);
- osMutexRelease(context->mutex);
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] All AI services started successfully", AI_MANAGER_LOG_TAG);
- return AI_SERVICE_OK;
-}
-
-ai_service_error_t ai_manager_stop(ai_manager_context_t *context)
-{
- if (context == NULL) {
- return AI_SERVICE_ERROR_INVALID_PARAM;
- }
-
- osMutexAcquire(context->mutex, osWaitForever);
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Stopping AI services", AI_MANAGER_LOG_TAG);
-
- // 结束当前对话
- if (context->is_conversation_active) {
- ai_manager_end_conversation(context);
- }
-
- // 停止TTS服务
- if (context->tts_context != NULL) {
- tts_server_stop(context->tts_context);
- }
-
- // 停止Chat服务
- if (context->chat_context != NULL) {
- chat_server_stop(context->chat_context);
- }
-
- // 停止ASR服务
- if (context->asr_context != NULL) {
- asr_server_stop(context->asr_context);
- }
-
- ai_manager_set_state(context, AI_MANAGER_STATE_IDLE);
- osMutexRelease(context->mutex);
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] All AI services stopped", AI_MANAGER_LOG_TAG);
- return AI_SERVICE_OK;
-}
-
-ai_service_error_t ai_manager_start_conversation(ai_manager_context_t *context,
- const char *session_id)
-{
- if (context == NULL) {
- return AI_SERVICE_ERROR_INVALID_PARAM;
- }
-
- osMutexAcquire(context->mutex, osWaitForever);
-
- if (context->state != AI_MANAGER_STATE_READY) {
- osMutexRelease(context->mutex);
- WEARABLE_LOGW(WEARABLE_LOG_MODULE_APP, "[%s] Manager not ready for conversation", AI_MANAGER_LOG_TAG);
- return AI_SERVICE_ERROR_NOT_CONNECTED;
- }
-
- if (context->is_conversation_active) {
- osMutexRelease(context->mutex);
- WEARABLE_LOGW(WEARABLE_LOG_MODULE_APP, "[%s] Conversation already active", AI_MANAGER_LOG_TAG);
- return AI_SERVICE_ERROR_ALREADY_CONNECTED;
- }
-
- // 设置会话ID
- if (session_id != NULL) {
- strncpy(context->current_session_id, session_id, sizeof(context->current_session_id) - 1);
- context->current_session_id[sizeof(context->current_session_id) - 1] = '\0';
- } else {
- ai_manager_generate_session_id(context->current_session_id,
- sizeof(context->current_session_id));
- }
-
- context->is_conversation_active = true;
- context->stats.conversation_count++;
- context->stats.last_conversation_time = ai_manager_get_timestamp();
-
- osMutexRelease(context->mutex);
-
- // 发送对话开始事件
- ai_event_data_t event = {
- .type = AI_EVENT_CONVERSATION_START,
- .timestamp = ai_manager_get_timestamp(),
- .is_final = true
- };
- strncpy(event.session_id, context->current_session_id, sizeof(event.session_id) - 1);
- ai_manager_send_event(context, &event);
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Conversation started: %s",
- AI_MANAGER_LOG_TAG, context->current_session_id);
- return AI_SERVICE_OK;
-}
-
-ai_service_error_t ai_manager_end_conversation(ai_manager_context_t *context)
-{
- if (context == NULL) {
- return AI_SERVICE_ERROR_INVALID_PARAM;
- }
-
- osMutexAcquire(context->mutex, osWaitForever);
-
- if (!context->is_conversation_active) {
- osMutexRelease(context->mutex);
- return AI_SERVICE_OK; // 已经结束了
- }
-
- // 停止录音
- if (context->is_recording_active) {
- ai_media_record_stop();
- context->is_recording_active = false;
- }
-
- // 停止播放
- if (context->is_playback_active) {
- ai_media_play_stop();
- context->is_playback_active = false;
- }
-
- context->is_conversation_active = false;
- ai_manager_set_state(context, AI_MANAGER_STATE_READY);
-
- osMutexRelease(context->mutex);
-
- // 发送对话结束事件
- ai_event_data_t event = {
- .type = AI_EVENT_CONVERSATION_END,
- .timestamp = ai_manager_get_timestamp(),
- .is_final = true
- };
- strncpy(event.session_id, context->current_session_id, sizeof(event.session_id) - 1);
- ai_manager_send_event(context, &event);
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Conversation ended: %s",
- AI_MANAGER_LOG_TAG, context->current_session_id);
- return AI_SERVICE_OK;
-}
-
-ai_service_error_t ai_manager_start_speech_input(ai_manager_context_t *context)
-{
- if (context == NULL) {
- return AI_SERVICE_ERROR_INVALID_PARAM;
- }
-
- osMutexAcquire(context->mutex, osWaitForever);
-
- if (!context->is_conversation_active) {
- osMutexRelease(context->mutex);
- WEARABLE_LOGW(WEARABLE_LOG_MODULE_APP, "[%s] No active conversation", AI_MANAGER_LOG_TAG);
- return AI_SERVICE_ERROR_NOT_CONNECTED;
- }
-
- if (context->is_recording_active) {
- osMutexRelease(context->mutex);
- return AI_SERVICE_OK; // 已经在录音了
- }
-
- // 停止当前TTS播放
- if (context->is_playback_active) {
- ai_media_play_stop();
- context->is_playback_active = false;
- }
-
- // 开始ASR识别
- if (asr_server_start_recognition(context->asr_context, context->current_session_id) != AI_SERVICE_OK) {
- osMutexRelease(context->mutex);
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Failed to start ASR recognition", AI_MANAGER_LOG_TAG);
- return AI_SERVICE_ERROR_INTERNAL;
- }
-
- // 开始录音
- ai_media_record_start((uint8_t*)"pcm");
- context->is_recording_active = true;
- ai_manager_set_state(context, AI_MANAGER_STATE_LISTENING);
-
- osMutexRelease(context->mutex);
-
- // 发送语音开始事件
- ai_event_data_t event = {
- .type = AI_EVENT_SPEECH_START,
- .timestamp = ai_manager_get_timestamp(),
- .is_final = false
- };
- strncpy(event.session_id, context->current_session_id, sizeof(event.session_id) - 1);
- ai_manager_send_event(context, &event);
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Speech input started", AI_MANAGER_LOG_TAG);
- return AI_SERVICE_OK;
-}
-
-ai_service_error_t ai_manager_stop_speech_input(ai_manager_context_t *context)
-{
- if (context == NULL) {
- return AI_SERVICE_ERROR_INVALID_PARAM;
- }
-
- osMutexAcquire(context->mutex, osWaitForever);
-
- if (!context->is_recording_active) {
- osMutexRelease(context->mutex);
- return AI_SERVICE_OK; // 已经停止了
- }
-
- // 停止录音
- ai_media_record_stop();
- context->is_recording_active = false;
-
- // 停止ASR识别
- asr_server_stop_recognition(context->asr_context);
-
- ai_manager_set_state(context, AI_MANAGER_STATE_PROCESSING);
- osMutexRelease(context->mutex);
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Speech input stopped", AI_MANAGER_LOG_TAG);
- return AI_SERVICE_OK;
-}
-
-ai_service_error_t ai_manager_send_text_message(ai_manager_context_t *context,
- const char *text)
-{
- if (context == NULL || text == NULL) {
- return AI_SERVICE_ERROR_INVALID_PARAM;
- }
-
- osMutexAcquire(context->mutex, osWaitForever);
-
- if (!context->is_conversation_active) {
- osMutexRelease(context->mutex);
- WEARABLE_LOGW(WEARABLE_LOG_MODULE_APP, "[%s] No active conversation", AI_MANAGER_LOG_TAG);
- return AI_SERVICE_ERROR_NOT_CONNECTED;
- }
-
- // 发送消息到Chat服务
- chat_message_t message = {
- .role = CHAT_ROLE_USER,
- .content = (char*)text,
- .timestamp = ai_manager_get_timestamp()
- };
-
- if (chat_server_send_message(context->chat_context, message.content, NULL) != AI_SERVICE_OK) {
- osMutexRelease(context->mutex);
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Failed to send chat message", AI_MANAGER_LOG_TAG);
- return AI_SERVICE_ERROR_INTERNAL;
- }
-
- context->stats.chat_request_count++;
- ai_manager_set_state(context, AI_MANAGER_STATE_PROCESSING);
- osMutexRelease(context->mutex);
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Text message sent: %s", AI_MANAGER_LOG_TAG, text);
- return AI_SERVICE_OK;
-}
-
-ai_service_error_t ai_manager_stop_tts_playback(ai_manager_context_t *context)
-{
- if (context == NULL) {
- return AI_SERVICE_ERROR_INVALID_PARAM;
- }
-
- osMutexAcquire(context->mutex, osWaitForever);
-
- if (context->is_playback_active) {
- ai_media_play_stop();
- tts_server_stop_synthesis(context->tts_context);
- context->is_playback_active = false;
- ai_manager_set_state(context, AI_MANAGER_STATE_READY);
- }
-
- osMutexRelease(context->mutex);
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] TTS playback stopped", AI_MANAGER_LOG_TAG);
- return AI_SERVICE_OK;
-}
-
-void ai_manager_set_event_callback(ai_manager_context_t *context,
- ai_event_callback_t callback,
- void *user_data)
-{
- if (context == NULL) {
- return;
- }
-
- osMutexAcquire(context->mutex, osWaitForever);
- context->on_event = callback;
- context->user_data = user_data;
- osMutexRelease(context->mutex);
-}
-
-ai_manager_state_t ai_manager_get_state(ai_manager_context_t *context)
-{
- if (context == NULL) {
- return AI_MANAGER_STATE_ERROR;
- }
-
- osMutexAcquire(context->mutex, osWaitForever);
- ai_manager_state_t state = context->state;
- osMutexRelease(context->mutex);
-
- return state;
-}
-
-const ai_manager_stats_t* ai_manager_get_stats(ai_manager_context_t *context)
-{
- if (context == NULL) {
- return NULL;
- }
-
- return &context->stats;
-}
-
-bool ai_manager_is_service_ready(ai_manager_context_t *context,
- ai_service_type_t service_type)
-{
- if (context == NULL) {
- return false;
- }
-
- switch (service_type) {
- case AI_SERVICE_TYPE_ASR:
- return (context->asr_context != NULL &&
- ai_service_get_state(&context->asr_context->base) == AI_SERVICE_STATE_CONNECTED);
- case AI_SERVICE_TYPE_CHAT:
- return (context->chat_context != NULL &&
- ai_service_get_state(&context->chat_context->base) == AI_SERVICE_STATE_CONNECTED);
- case AI_SERVICE_TYPE_TTS:
- return (context->tts_context != NULL &&
- ai_service_get_state(&context->tts_context->base) == AI_SERVICE_STATE_CONNECTED);
- case AI_SERVICE_TYPE_ALL:
- return (ai_manager_is_service_ready(context, AI_SERVICE_TYPE_ASR) &&
- ai_manager_is_service_ready(context, AI_SERVICE_TYPE_CHAT) &&
- ai_manager_is_service_ready(context, AI_SERVICE_TYPE_TTS));
- default:
- return false;
- }
-}
-
-/* ==================== 工具函数实现 ==================== */
-
-void ai_manager_create_default_config(ai_manager_config_t *config)
-{
- if (config == NULL) {
- return;
- }
-
- memset(config, 0, sizeof(ai_manager_config_t));
-
- // ASR默认配置
- strcpy(config->asr_server_url, "ws://localhost");
- config->asr_server_port = 8080;
- asr_server_create_default_audio_config(&config->asr_audio_config);
- asr_server_create_default_recognition_config(&config->asr_recognition_config);
-
- // Chat默认配置
- strcpy(config->chat_server_url, "ws://localhost");
- config->chat_server_port = 8081;
- chat_server_create_default_model_config(&config->chat_model_config);
-
- // TTS默认配置
- strcpy(config->tts_server_url, "ws://localhost");
- config->tts_server_port = 8082;
- tts_server_create_default_audio_config(&config->tts_audio_config);
- tts_server_create_default_voice_config(&config->tts_voice_config);
-
- // 通用配置
- config->connect_timeout_ms = AI_CONNECT_TIMEOUT_MS;
- config->response_timeout_ms = AI_MANAGER_RESPONSE_TIMEOUT_MS;
- config->auto_reconnect = true;
- config->max_retry_count = AI_MANAGER_MAX_RETRY_COUNT;
-}
-
-void ai_manager_generate_session_id(char *session_id, size_t max_len)
-{
- if (session_id == NULL || max_len == 0) {
- return;
- }
-
- uint32_t timestamp = ai_manager_get_timestamp();
- static uint32_t counter = 0;
-
- snprintf(session_id, max_len, "ai_session_%u_%u", timestamp, ++counter);
-}
-
-const char* ai_manager_state_to_string(ai_manager_state_t state)
-{
- switch (state) {
- case AI_MANAGER_STATE_IDLE: return "IDLE";
- case AI_MANAGER_STATE_INITIALIZING: return "INITIALIZING";
- case AI_MANAGER_STATE_READY: return "READY";
- case AI_MANAGER_STATE_LISTENING: return "LISTENING";
- case AI_MANAGER_STATE_PROCESSING: return "PROCESSING";
- case AI_MANAGER_STATE_SPEAKING: return "SPEAKING";
- case AI_MANAGER_STATE_ERROR: return "ERROR";
- case AI_MANAGER_STATE_SHUTDOWN: return "SHUTDOWN";
- default: return "UNKNOWN";
- }
-}
-
-const char* ai_manager_event_type_to_string(ai_event_type_t event_type)
-{
- switch (event_type) {
- case AI_EVENT_CONVERSATION_START: return "CONVERSATION_START";
- case AI_EVENT_SPEECH_START: return "SPEECH_START";
- case AI_EVENT_SPEECH_PARTIAL: return "SPEECH_PARTIAL";
- case AI_EVENT_SPEECH_END: return "SPEECH_END";
- case AI_EVENT_CHAT_RESPONSE_START: return "CHAT_RESPONSE_START";
- case AI_EVENT_CHAT_RESPONSE_PARTIAL: return "CHAT_RESPONSE_PARTIAL";
- case AI_EVENT_CHAT_RESPONSE_END: return "CHAT_RESPONSE_END";
- case AI_EVENT_TTS_START: return "TTS_START";
- case AI_EVENT_TTS_END: return "TTS_END";
- case AI_EVENT_CONVERSATION_END: return "CONVERSATION_END";
- case AI_EVENT_ERROR: return "ERROR";
- default: return "UNKNOWN";
- }
-}
-
-void ai_manager_free_event_data(ai_event_data_t *event)
-{
- if (event == NULL) {
- return;
- }
-
- if (event->text != NULL) {
- free(event->text);
- event->text = NULL;
- }
-
- if (event->error_message != NULL) {
- free(event->error_message);
- event->error_message = NULL;
- }
-}
-
-/* ==================== 内部函数实现 ==================== */
-
-static void ai_manager_main_thread(void *arg)
-{
- ai_manager_context_t *context = (ai_manager_context_t *)arg;
- ai_event_data_t event;
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Main thread started", AI_MANAGER_LOG_TAG);
-
- while (context->state != AI_MANAGER_STATE_SHUTDOWN) {
- // 处理事件队列中的事件
- osStatus_t status = osMessageQueueGet(context->event_queue, &event, NULL, 1000);
- if (status == osOK) {
- // 调用用户回调
- if (context->on_event != NULL) {
- context->on_event(context->user_data, &event);
- }
-
- // 清理事件数据
- ai_manager_free_event_data(&event);
- }
- }
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Main thread exited", AI_MANAGER_LOG_TAG);
-}
-
-static ai_service_error_t ai_manager_init_services(ai_manager_context_t *context)
-{
- // 初始化ASR服务
- context->asr_context = (asr_server_context_t *)malloc(sizeof(asr_server_context_t));
- if (context->asr_context == NULL) {
- return AI_SERVICE_ERROR_MEMORY_ALLOC;
- }
-
- ai_service_config_t asr_config = {
- .server_port = context->config.asr_server_port,
- .connect_timeout_ms = context->config.connect_timeout_ms,
- .receive_timeout_ms = context->config.response_timeout_ms,
- .auto_reconnect = context->config.auto_reconnect,
- .max_retry_count = context->config.max_retry_count
- };
- strcpy(asr_config.server_url, context->config.asr_server_url);
-
- if (asr_server_init(context->asr_context,
- asr_config.server_url,
- &context->config.asr_audio_config,
- &context->config.asr_recognition_config) != AI_SERVICE_OK) {
- free(context->asr_context);
- context->asr_context = NULL;
- return AI_SERVICE_ERROR_INTERNAL;
- }
-
- // 设置ASR回调
- asr_server_set_callbacks(context->asr_context,
- ai_manager_asr_on_result,
- NULL, // on_recognition_start
- NULL, // on_recognition_end
- NULL); // on_audio_level
-
- // 初始化Chat服务
- context->chat_context = (chat_server_context_t *)malloc(sizeof(chat_server_context_t));
- if (context->chat_context == NULL) {
- asr_server_destroy(context->asr_context);
- free(context->asr_context);
- return AI_SERVICE_ERROR_MEMORY_ALLOC;
- }
-
- ai_service_config_t chat_config = {
- .server_port = context->config.chat_server_port,
- .connect_timeout_ms = context->config.connect_timeout_ms,
- .receive_timeout_ms = context->config.response_timeout_ms,
- .auto_reconnect = context->config.auto_reconnect,
- .max_retry_count = context->config.max_retry_count
- };
- strcpy(chat_config.server_url, context->config.chat_server_url);
-
- if (chat_server_init(context->chat_context,
- chat_config.server_url,
- &context->config.chat_model_config) != AI_SERVICE_OK) {
- asr_server_destroy(context->asr_context);
- free(context->asr_context);
- free(context->chat_context);
- context->chat_context = NULL;
- return AI_SERVICE_ERROR_INTERNAL;
- }
-
- // 设置Chat回调
- chat_server_set_callbacks(context->chat_context,
- NULL, // on_chat_start
- ai_manager_chat_on_response,
- NULL, // on_chat_complete
- NULL); // on_chat_streaming
-
- // 初始化TTS服务
- context->tts_context = (tts_server_context_t *)malloc(sizeof(tts_server_context_t));
- if (context->tts_context == NULL) {
- chat_server_destroy(context->chat_context);
- free(context->chat_context);
- asr_server_destroy(context->asr_context);
- free(context->asr_context);
- return AI_SERVICE_ERROR_MEMORY_ALLOC;
- }
-
- ai_service_config_t tts_config = {
- .server_port = context->config.tts_server_port,
- .connect_timeout_ms = context->config.connect_timeout_ms,
- .receive_timeout_ms = context->config.response_timeout_ms,
- .auto_reconnect = context->config.auto_reconnect,
- .max_retry_count = context->config.max_retry_count
- };
- strcpy(tts_config.server_url, context->config.tts_server_url);
-
- if (tts_server_init(context->tts_context,
- tts_config.server_url,
- &context->config.tts_audio_config,
- &context->config.tts_voice_config) != AI_SERVICE_OK) {
- chat_server_destroy(context->chat_context);
- free(context->chat_context);
- asr_server_destroy(context->asr_context);
- free(context->asr_context);
- free(context->tts_context);
- context->tts_context = NULL;
- return AI_SERVICE_ERROR_INTERNAL;
- }
-
- // 设置TTS回调
- tts_server_set_callbacks(context->tts_context,
- NULL, // on_synthesis_start
- ai_manager_tts_on_result,
- NULL, // on_synthesis_complete
- NULL, // on_playback_start
- NULL, // on_playback_complete
- NULL); // on_playback_error
-
- return AI_SERVICE_OK;
-}
-
-static ai_service_error_t ai_manager_deinit_services(ai_manager_context_t *context)
-{
- if (context->tts_context != NULL) {
- tts_server_destroy(context->tts_context);
- free(context->tts_context);
- context->tts_context = NULL;
- }
-
- if (context->chat_context != NULL) {
- chat_server_destroy(context->chat_context);
- free(context->chat_context);
- context->chat_context = NULL;
- }
-
- if (context->asr_context != NULL) {
- asr_server_destroy(context->asr_context);
- free(context->asr_context);
- context->asr_context = NULL;
- }
-
- return AI_SERVICE_OK;
-}
-
-static void ai_manager_set_state(ai_manager_context_t *context, ai_manager_state_t new_state)
-{
- if (context == NULL) {
- return;
- }
-
- ai_manager_state_t old_state = context->state;
- context->state = new_state;
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] State changed: %s -> %s",
- AI_MANAGER_LOG_TAG,
- ai_manager_state_to_string(old_state),
- ai_manager_state_to_string(new_state));
-}
-
-static void ai_manager_send_event(ai_manager_context_t *context, const ai_event_data_t *event)
-{
- if (context == NULL || event == NULL) {
- return;
- }
-
- // 复制事件数据
- ai_event_data_t event_copy = *event;
-
- // 复制文本内容
- if (event->text != NULL) {
- event_copy.text = (char *)malloc(strlen(event->text) + 1);
- if (event_copy.text != NULL) {
- strcpy(event_copy.text, event->text);
- }
- }
-
- // 复制错误信息
- if (event->error_message != NULL) {
- event_copy.error_message = (char *)malloc(strlen(event->error_message) + 1);
- if (event_copy.error_message != NULL) {
- strcpy(event_copy.error_message, event->error_message);
- }
- }
-
- // 发送到事件队列
- osStatus_t status = osMessageQueuePut(context->event_queue, &event_copy, 0, 0);
- if (status != osOK) {
- WEARABLE_LOGW(WEARABLE_LOG_MODULE_APP, "[%s] Failed to send event: %s",
- AI_MANAGER_LOG_TAG, ai_manager_event_type_to_string(event->type));
- // 清理分配的内存
- ai_manager_free_event_data(&event_copy);
- }
-}
-
-static uint32_t ai_manager_get_timestamp(void)
-{
- return (uint32_t)(osKernelGetTickCount() * 1000 / osKernelGetTickFreq());
-}
-
-/* ==================== 回调函数实现 ==================== */
-
-static void ai_manager_asr_on_result(void *user_data, const asr_recognition_result_t *result)
-{
- ai_manager_context_t *context = (ai_manager_context_t *)user_data;
- if (context == NULL || result == NULL) {
- return;
- }
-
- context->stats.asr_recognition_count++;
-
- ai_event_data_t event = {
- .type = result->is_final ? AI_EVENT_SPEECH_END : AI_EVENT_SPEECH_PARTIAL,
- .text = result->text,
- .text_length = result->text ? strlen(result->text) : 0,
- .confidence = result->confidence,
- .is_final = result->is_final,
- .timestamp = ai_manager_get_timestamp()
- };
- strncpy(event.session_id, context->current_session_id, sizeof(event.session_id) - 1);
-
- ai_manager_send_event(context, &event);
-
- // 如果是最终结果，发送到Chat服务
- if (result->is_final && result->text != NULL && strlen(result->text) > 0) {
- ai_manager_send_text_message(context, result->text);
- }
-}
-
-static void ai_manager_asr_on_error(void *user_data, int error_code, const char *error_msg)
-{
- ai_manager_context_t *context = (ai_manager_context_t *)user_data;
- if (context == NULL) {
- return;
- }
-
- context->stats.total_errors++;
-
- ai_event_data_t event = {
- .type = AI_EVENT_ERROR,
- .error_code = error_code,
- .error_message = (char*)error_msg,
- .timestamp = ai_manager_get_timestamp(),
- .is_final = true
- };
- strncpy(event.session_id, context->current_session_id, sizeof(event.session_id) - 1);
-
- ai_manager_send_event(context, &event);
-}
-
-static void ai_manager_chat_on_response(void *user_data, const chat_response_t *response)
-{
- ai_manager_context_t *context = (ai_manager_context_t *)user_data;
- if (context == NULL || response == NULL) {
- return;
- }
-
- ai_event_type_t event_type;
- if (response->is_streaming && !response->is_final) {
- event_type = AI_EVENT_CHAT_RESPONSE_PARTIAL;
- } else if (response->is_final) {
- event_type = AI_EVENT_CHAT_RESPONSE_END;
- } else {
- event_type = AI_EVENT_CHAT_RESPONSE_START;
- ai_manager_set_state(context, AI_MANAGER_STATE_SPEAKING);
- }
-
- ai_event_data_t event = {
- .type = event_type,
- .text = response->content,
- .text_length = response->content ? strlen(response->content) : 0,
- .is_final = response->is_final,
- .timestamp = ai_manager_get_timestamp()
- };
- strncpy(event.session_id, context->current_session_id, sizeof(event.session_id) - 1);
-
- ai_manager_send_event(context, &event);
-
- // 如果有内容，发送到TTS服务
- if (response->content != NULL && strlen(response->content) > 0) {
- tts_synthesis_request_t tts_request = {
- .text = response->content,
- .session_id = context->current_session_id
- };
- tts_server_synthesize_request(context->tts_context, &tts_request);
- }
-}
-
-static void ai_manager_chat_on_error(void *user_data, int error_code, const char *error_msg)
-{
- ai_manager_context_t *context = (ai_manager_context_t *)user_data;
- if (context == NULL) {
- return;
- }
-
- context->stats.total_errors++;
-
- ai_event_data_t event = {
- .type = AI_EVENT_ERROR,
- .error_code = error_code,
- .error_message = (char*)error_msg,
- .timestamp = ai_manager_get_timestamp(),
- .is_final = true
- };
- strncpy(event.session_id, context->current_session_id, sizeof(event.session_id) - 1);
-
- ai_manager_send_event(context, &event);
-}
-
-static void ai_manager_tts_on_result(void *user_data, const tts_synthesis_result_t *result)
-{
- ai_manager_context_t *context = (ai_manager_context_t *)user_data;
- if (context == NULL || result == NULL) {
- return;
- }
-
- context->stats.tts_synthesis_count++;
-
- // 播放音频数据
- if (result->audio_data != NULL && result->audio_length > 0) {
- if (!context->is_playback_active) {
- ai_media_play_start((uint8_t*)"pcm");
- context->is_playback_active = true;
-
- ai_event_data_t event = {
- .type = AI_EVENT_TTS_START,
- .timestamp = ai_manager_get_timestamp(),
- .is_final = false
- };
- strncpy(event.session_id, context->current_session_id, sizeof(event.session_id) - 1);
- ai_manager_send_event(context, &event);
- }
-
- ai_media_play_buffer((uint8_t *)result->audio_data, result->audio_length);
- }
-
- // 如果是最后一个片段
- if (result->is_final) {
- ai_event_data_t event = {
- .type = AI_EVENT_TTS_END,
- .timestamp = ai_manager_get_timestamp(),
- .is_final = true
- };
- strncpy(event.session_id, context->current_session_id, sizeof(event.session_id) - 1);
- ai_manager_send_event(context, &event);
-
- ai_manager_set_state(context, AI_MANAGER_STATE_READY);
- }
-}
-
-static void ai_manager_tts_on_error(void *user_data, int error_code, const char *error_msg)
-{
- ai_manager_context_t *context = (ai_manager_context_t *)user_data;
- if (context == NULL) {
- return;
- }
-
- context->stats.total_errors++;
-
- ai_event_data_t event = {
- .type = AI_EVENT_ERROR,
- .error_code = error_code,
- .error_message = (char*)error_msg,
- .timestamp = ai_manager_get_timestamp(),
- .is_final = true
- };
- strncpy(event.session_id, context->current_session_id, sizeof(event.session_id) - 1);
-
- ai_manager_send_event(context, &event);
-}
-
-static void ai_manager_record_callback(uint8_t *data, uint32_t size)
-{
- if (g_current_manager == NULL || data == NULL || size == 0) {
- return;
- }
-
- ai_manager_context_t *context = g_current_manager;
-
- // 如果正在录音且ASR服务可用，发送音频数据
- if (context->is_recording_active && context->asr_context != NULL) {
- asr_server_send_audio(context->asr_context, (const char*)data, size);
- }
-}
-
-#ifdef __cplusplus
-}
-#endif
\ No newline at end of file
--- /dev/null
+/**
+ * @file ai_services.c
+ * @brief AI服务统一接口实现 - LiteOS-M优化版v2
+ * @version 2.0
+ * @date 2024-01-20
+ */
+
+#include "ai_services.h"
+#include "ai_connection_manager.h"
+#include "ai_memory_pool.h"
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+#ifndef __TEST_MODE__
+#include "wearable_log.h"
+#include "dev_authentication.h"
+#define AI_LOG_TAG "AI_SERVICES"
+#define AI_LOGI(fmt, ...) WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] " fmt, AI_LOG_TAG, ##__VA_ARGS__)
+#define AI_LOGE(fmt, ...) WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] " fmt, AI_LOG_TAG, ##__VA_ARGS__)
+#define AI_LOGW(fmt, ...) WEARABLE_LOGW(WEARABLE_LOG_MODULE_APP, "[%s] " fmt, AI_LOG_TAG, ##__VA_ARGS__)
+#else
+#define AI_LOGI(fmt, ...) printf("[AI_SERVICES] " fmt "\n", ##__VA_ARGS__)
+#define AI_LOGE(fmt, ...) printf("[AI_SERVICES] ERROR: " fmt "\n", ##__VA_ARGS__)
+#define AI_LOGW(fmt, ...) printf("[AI_SERVICES] WARN: " fmt "\n", ##__VA_ARGS__)
+#endif
+
+/* ================================ 内部常量定义 ================================ */
+
+#define JSON_BUFFER_SIZE 512 // JSON缓冲区大小
+#define MESSAGE_ID_LENGTH 16 // 消息ID长度
+#define MAX_AUDIO_CHUNK_SIZE 1024 // 最大音频块大小
+
+/* 语音类型名称映射 */
+static const char* g_voice_names[TTS_VOICE_COUNT] = {
+ "xiaoyun", "xiaogang", "xiaomei", "xiaoli"
+};
+
+/* 状态名称映射 */
+static const char* g_asr_state_names[] = {
+ "IDLE", "LISTENING", "RECOGNIZING", "COMPLETED", "ERROR"
+};
+
+static const char* g_chat_state_names[] = {
+ "IDLE", "SENDING", "WAITING", "RECEIVING", "COMPLETED", "ERROR"
+};
+
+static const char* g_tts_state_names[] = {
+ "IDLE", "SYNTHESIZING", "PLAYING", "COMPLETED", "ERROR"
+};
+
+/* ================================ 内部函数声明 ================================ */
+
+static ai_error_t build_asr_start_message(const char *session_id, const asr_config_t *config, char *json_buffer, size_t buffer_size);
+static ai_error_t build_chat_message(const char *message, const char *session_id, const chat_config_t *config, char *json_buffer, size_t buffer_size);
+static ai_error_t build_tts_request(const char *text, const char *session_id, const tts_config_t *config, char *json_buffer, size_t buffer_size);
+static ai_error_t parse_asr_response(const char *json_data, asr_result_t *result);
+static ai_error_t parse_chat_response(const char *json_data, chat_message_t *message);
+static ai_error_t parse_tts_response(const char *json_data, tts_result_t *result);
+static void generate_message_id(char *message_id, size_t buffer_size);
+static uint32_t get_current_timestamp(void);
+static void connection_event_handler(const ai_event_t *event, void *user_data);
+static ai_error_t change_asr_state(ai_services_context_t *context, asr_state_t new_state);
+static ai_error_t change_chat_state(ai_services_context_t *context, chat_state_t new_state);
+static ai_error_t change_tts_state(ai_services_context_t *context, tts_state_t new_state);
+
+/* ================================ 公共接口实现 ================================ */
+
+ai_error_t ai_services_init(ai_services_context_t *context)
+{
+ if (context == NULL) {
+ AI_LOGE("Invalid context parameter");
+ return AI_ERROR_INVALID_PARAM;
+ }
+
+ if (context->is_initialized) {
+ AI_LOGW("AI services already initialized");
+ return AI_ERROR_ALREADY_INITIALIZED;
+ }
+
+ AI_LOGI("Initializing AI services...");
+
+ /* 初始化上下文 */
+ memset(context, 0, sizeof(ai_services_context_t));
+
+ /* 设置默认状态 */
+ context->asr_state = ASR_STATE_IDLE;
+ context->chat_state = CHAT_STATE_IDLE;
+ context->tts_state = TTS_STATE_IDLE;
+
+ /* 创建默认配置 */
+ ai_asr_create_default_config(&context->asr_config);
+ ai_chat_create_default_config(&context->chat_config);
+ ai_tts_create_default_config(&context->tts_config);
+
+ /* 生成初始会话ID */
+ ai_services_generate_session_id(context->current_session_id, sizeof(context->current_session_id));
+
+ context->last_activity_time = get_current_timestamp();
+ context->is_initialized = true;
+
+ AI_LOGI("AI services initialized successfully");
+ return AI_OK;
+}
+
+ai_error_t ai_services_destroy(ai_services_context_t *context)
+{
+ if (context == NULL) {
+ return AI_ERROR_INVALID_PARAM;
+ }
+
+ if (!context->is_initialized) {
+ return AI_ERROR_NOT_INITIALIZED;
+ }
+
+ AI_LOGI("Destroying AI services...");
+
+ /* 停止所有活动服务 */
+ if (context->asr_state != ASR_STATE_IDLE) {
+ ai_asr_stop(context);
+ }
+
+ if (context->tts_state != TTS_STATE_IDLE) {
+ ai_tts_stop(context);
+ }
+
+ /* 重置上下文 */
+ memset(context, 0, sizeof(ai_services_context_t));
+
+ AI_LOGI("AI services destroyed");
+ return AI_OK;
+}
+
+/* ================================ ASR服务接口实现 ================================ */
+
+ai_error_t ai_asr_configure(ai_services_context_t *context, const asr_config_t *config)
+{
+ if (context == NULL || config == NULL) {
+ return AI_ERROR_INVALID_PARAM;
+ }
+
+ if (!context->is_initialized) {
+ return AI_ERROR_NOT_INITIALIZED;
+ }
+
+ memcpy(&context->asr_config, config, sizeof(asr_config_t));
+ AI_LOGI("ASR configured: language=%s, vad=%s, punctuation=%s",
+ config->language,
+ config->enable_vad ? "enabled" : "disabled",
+ config->enable_punctuation ? "enabled" : "disabled");
+
+ return AI_OK;
+}
+
+ai_error_t ai_asr_set_callbacks(ai_services_context_t *context,
+ asr_result_callback_t result_cb,
+ asr_error_callback_t error_cb,
+ asr_state_callback_t state_cb,
+ void *user_data)
+{
+ if (context == NULL) {
+ return AI_ERROR_INVALID_PARAM;
+ }
+
+ if (!context->is_initialized) {
+ return AI_ERROR_NOT_INITIALIZED;
+ }
+
+ context->asr_result_cb = result_cb;
+ context->asr_error_cb = error_cb;
+ context->asr_state_cb = state_cb;
+ context->user_data = user_data;
+
+ AI_LOGI("ASR callbacks set");
+ return AI_OK;
+}
+
+ai_error_t ai_asr_start(ai_services_context_t *context, const char *session_id)
+{
+ if (context == NULL) {
+ return AI_ERROR_INVALID_PARAM;
+ }
+
+ if (!context->is_initialized) {
+ return AI_ERROR_NOT_INITIALIZED;
+ }
+
+ if (context->asr_state != ASR_STATE_IDLE) {
+ AI_LOGW("ASR already active, stopping first");
+ ai_asr_stop(context);
+ }
+
+ /* 使用提供的会话ID或当前会话ID */
+ const char *use_session_id = session_id ? session_id : context->current_session_id;
+
+ AI_LOGI("Starting ASR with session ID: %s", use_session_id);
+
+ /* 检查ASR连接状态 */
+ ai_connection_state_t conn_state = ai_connection_manager_get_connection_state(AI_SERVICE_ASR);
+ if (conn_state != AI_CONN_STATE_CONNECTED) {
+ AI_LOGE("ASR service not connected");
+ return AI_ERROR_SERVICE_UNAVAILABLE;
+ }
+
+ /* 构建启动消息 */
+ char json_buffer[JSON_BUFFER_SIZE];
+ ai_error_t ret = build_asr_start_message(use_session_id, &context->asr_config, json_buffer, sizeof(json_buffer));
+ if (ret != AI_OK) {
+ AI_LOGE("Failed to build ASR start message");
+ return ret;
+ }
+
+ /* 发送启动消息 */
+ ret = ai_connection_manager_send_data(AI_SERVICE_ASR, json_buffer, strlen(json_buffer));
+ if (ret != AI_OK) {
+ AI_LOGE("Failed to send ASR start message");
+ return ret;
+ }
+
+ /* 更新状态 */
+ change_asr_state(context, ASR_STATE_LISTENING);
+ strncpy(context->current_session_id, use_session_id, sizeof(context->current_session_id) - 1);
+ context->last_activity_time = get_current_timestamp();
+
+ return AI_OK;
+}
+
+ai_error_t ai_asr_send_audio(ai_services_context_t *context, const uint8_t *audio_data, uint32_t data_size)
+{
+ if (context == NULL || audio_data == NULL || data_size == 0) {
+ return AI_ERROR_INVALID_PARAM;
+ }
+
+ if (!context->is_initialized) {
+ return AI_ERROR_NOT_INITIALIZED;
+ }
+
+ if (context->asr_state != ASR_STATE_LISTENING && context->asr_state != ASR_STATE_RECOGNIZING) {
+ AI_LOGW("ASR not in listening/recognizing state");
+ return AI_ERROR_STATE_INVALID;
+ }
+
+ /* 检查数据大小 */
+ if (data_size > MAX_AUDIO_CHUNK_SIZE) {
+ AI_LOGW("Audio chunk too large: %u bytes, splitting", data_size);
+
+ /* 分块发送 */
+ uint32_t offset = 0;
+ while (offset < data_size) {
+ uint32_t chunk_size = (data_size - offset > MAX_AUDIO_CHUNK_SIZE) ?
+ MAX_AUDIO_CHUNK_SIZE : (data_size - offset);
+
+ ai_error_t ret = ai_asr_send_audio(context, audio_data + offset, chunk_size);
+ if (ret != AI_OK) {
+ return ret;
+ }
+ offset += chunk_size;
+ }
+ return AI_OK;
+ }
+
+ /* 构建音频数据消息 */
+ ai_buffer_t *buffer = ai_memory_pool_alloc_network(AI_SERVICE_ASR, data_size + 64);
+ if (buffer == NULL) {
+ AI_LOGE("Failed to allocate network buffer for audio data");
+ return AI_ERROR_MEMORY_ALLOC;
+ }
+
+ /* 简化的二进制数据发送（实际实现中可能需要Base64编码） */
+ memcpy(buffer->buffer, audio_data, data_size);
+ buffer->used = data_size;
+
+ ai_error_t ret = ai_connection_manager_send_data(AI_SERVICE_ASR, (const char*)buffer->buffer, buffer->used);
+
+ ai_memory_pool_free(buffer);
+
+ if (ret != AI_OK) {
+ AI_LOGE("Failed to send audio data");
+ return ret;
+ }
+
+ /* 更新状态 */
+ if (context->asr_state == ASR_STATE_LISTENING) {
+ change_asr_state(context, ASR_STATE_RECOGNIZING);
+ }
+
+ context->last_activity_time = get_current_timestamp();
+
+ return AI_OK;
+}
+
+ai_error_t ai_asr_stop(ai_services_context_t *context)
+{
+ if (context == NULL) {
+ return AI_ERROR_INVALID_PARAM;
+ }
+
+ if (!context->is_initialized) {
+ return AI_ERROR_NOT_INITIALIZED;
+ }
+
+ if (context->asr_state == ASR_STATE_IDLE) {
+ return AI_OK; // 已经停止
+ }
+
+ AI_LOGI("Stopping ASR");
+
+ /* 发送停止消息 */
+ char stop_message[] = "{\"type\":\"stop\",\"session_id\":\"%s\"}";
+ char json_buffer[JSON_BUFFER_SIZE];
+ snprintf(json_buffer, sizeof(json_buffer), stop_message, context->current_session_id);
+
+ ai_connection_manager_send_data(AI_SERVICE_ASR, json_buffer, strlen(json_buffer));
+
+ /* 更新状态 */
+ change_asr_state(context, ASR_STATE_IDLE);
+
+ return AI_OK;
+}
+
+asr_state_t ai_asr_get_state(ai_services_context_t *context)
+{
+ if (context == NULL || !context->is_initialized) {
+ return ASR_STATE_ERROR;
+ }
+
+ return context->asr_state;
+}
+
+/* ================================ Chat服务接口实现 ================================ */
+
+ai_error_t ai_chat_configure(ai_services_context_t *context, const chat_config_t *config)
+{
+ if (context == NULL || config == NULL) {
+ return AI_ERROR_INVALID_PARAM;
+ }
+
+ if (!context->is_initialized) {
+ return AI_ERROR_NOT_INITIALIZED;
+ }
+
+ memcpy(&context->chat_config, config, sizeof(chat_config_t));
+ AI_LOGI("Chat configured: model=%s, temperature=%.2f, max_tokens=%d",
+ config->model_name, config->temperature, config->max_tokens);
+
+ return AI_OK;
+}
+
+ai_error_t ai_chat_set_callbacks(ai_services_context_t *context,
+ chat_response_callback_t response_cb,
+ chat_error_callback_t error_cb,
+ chat_state_callback_t state_cb,
+ void *user_data)
+{
+ if (context == NULL) {
+ return AI_ERROR_INVALID_PARAM;
+ }
+
+ if (!context->is_initialized) {
+ return AI_ERROR_NOT_INITIALIZED;
+ }
+
+ context->chat_response_cb = response_cb;
+ context->chat_error_cb = error_cb;
+ context->chat_state_cb = state_cb;
+ context->user_data = user_data;
+
+ AI_LOGI("Chat callbacks set");
+ return AI_OK;
+}
+
+ai_error_t ai_chat_send_message(ai_services_context_t *context, const char *message, const char *session_id)
+{
+ if (context == NULL || message == NULL || strlen(message) == 0) {
+ return AI_ERROR_INVALID_PARAM;
+ }
+
+ if (!context->is_initialized) {
+ return AI_ERROR_NOT_INITIALIZED;
+ }
+
+ if (context->chat_state != CHAT_STATE_IDLE) {
+ AI_LOGW("Chat busy, current state: %s", g_chat_state_names[context->chat_state]);
+ return AI_ERROR_STATE_INVALID;
+ }
+
+ /* 使用提供的会话ID或当前会话ID */
+ const char *use_session_id = session_id ? session_id : context->current_session_id;
+
+ AI_LOGI("Sending chat message: %.50s... (session: %s)", message, use_session_id);
+
+ /* 检查Chat连接状态 */
+ ai_connection_state_t conn_state = ai_connection_manager_get_connection_state(AI_SERVICE_CHAT);
+ if (conn_state != AI_CONN_STATE_CONNECTED) {
+ AI_LOGE("Chat service not connected");
+ return AI_ERROR_SERVICE_UNAVAILABLE;
+ }
+
+ /* 构建聊天消息 */
+ char json_buffer[JSON_BUFFER_SIZE];
+ ai_error_t ret = build_chat_message(message, use_session_id, &context->chat_config, json_buffer, sizeof(json_buffer));
+ if (ret != AI_OK) {
+ AI_LOGE("Failed to build chat message");
+ return ret;
+ }
+
+ /* 发送消息 */
+ change_chat_state(context, CHAT_STATE_SENDING);
+
+ ret = ai_connection_manager_send_data(AI_SERVICE_CHAT, json_buffer, strlen(json_buffer));
+ if (ret != AI_OK) {
+ AI_LOGE("Failed to send chat message");
+ change_chat_state(context, CHAT_STATE_ERROR);
+ return ret;
+ }
+
+ /* 更新状态 */
+ change_chat_state(context, CHAT_STATE_WAITING);
+ strncpy(context->current_session_id, use_session_id, sizeof(context->current_session_id) - 1);
+ context->last_activity_time = get_current_timestamp();
+
+ return AI_OK;
+}
+
+chat_state_t ai_chat_get_state(ai_services_context_t *context)
+{
+ if (context == NULL || !context->is_initialized) {
+ return CHAT_STATE_ERROR;
+ }
+
+ return context->chat_state;
+}
+
+/* ================================ TTS服务接口实现 ================================ */
+
+ai_error_t ai_tts_configure(ai_services_context_t *context, const tts_config_t *config)
+{
+ if (context == NULL || config == NULL) {
+ return AI_ERROR_INVALID_PARAM;
+ }
+
+ if (!context->is_initialized) {
+ return AI_ERROR_NOT_INITIALIZED;
+ }
+
+ memcpy(&context->tts_config, config, sizeof(tts_config_t));
+ AI_LOGI("TTS configured: voice=%s, volume=%d, speed=%d",
+ ai_tts_get_voice_name(config->voice_type), config->volume, config->speed);
+
+ return AI_OK;
+}
+
+ai_error_t ai_tts_set_callbacks(ai_services_context_t *context,
+ tts_result_callback_t result_cb,
+ tts_error_callback_t error_cb,
+ tts_state_callback_t state_cb,
+ void *user_data)
+{
+ if (context == NULL) {
+ return AI_ERROR_INVALID_PARAM;
+ }
+
+ if (!context->is_initialized) {
+ return AI_ERROR_NOT_INITIALIZED;
+ }
+
+ context->tts_result_cb = result_cb;
+ context->tts_error_cb = error_cb;
+ context->tts_state_cb = state_cb;
+ context->user_data = user_data;
+
+ AI_LOGI("TTS callbacks set");
+ return AI_OK;
+}
+
+ai_error_t ai_tts_synthesize(ai_services_context_t *context, const char *text, const char *session_id)
+{
+ if (context == NULL || text == NULL || strlen(text) == 0) {
+ return AI_ERROR_INVALID_PARAM;
+ }
+
+ if (!context->is_initialized) {
+ return AI_ERROR_NOT_INITIALIZED;
+ }
+
+ if (context->tts_state != TTS_STATE_IDLE) {
+ AI_LOGW("TTS busy, current state: %s", g_tts_state_names[context->tts_state]);
+ return AI_ERROR_STATE_INVALID;
+ }
+
+ /* 使用提供的会话ID或当前会话ID */
+ const char *use_session_id = session_id ? session_id : context->current_session_id;
+
+ AI_LOGI("Starting TTS synthesis: %.50s... (session: %s)", text, use_session_id);
+
+ /* 检查TTS连接状态 */
+ ai_connection_state_t conn_state = ai_connection_manager_get_connection_state(AI_SERVICE_TTS);
+ if (conn_state != AI_CONN_STATE_CONNECTED) {
+ AI_LOGE("TTS service not connected");
+ return AI_ERROR_SERVICE_UNAVAILABLE;
+ }
+
+ /* 构建TTS请求 */
+ char json_buffer[JSON_BUFFER_SIZE];
+ ai_error_t ret = build_tts_request(text, use_session_id, &context->tts_config, json_buffer, sizeof(json_buffer));
+ if (ret != AI_OK) {
+ AI_LOGE("Failed to build TTS request");
+ return ret;
+ }
+
+ /* 发送请求 */
+ change_tts_state(context, TTS_STATE_SYNTHESIZING);
+
+ ret = ai_connection_manager_send_data(AI_SERVICE_TTS, json_buffer, strlen(json_buffer));
+ if (ret != AI_OK) {
+ AI_LOGE("Failed to send TTS request");
+ change_tts_state(context, TTS_STATE_ERROR);
+ return ret;
+ }
+
+ /* 更新状态 */
+ strncpy(context->current_session_id, use_session_id, sizeof(context->current_session_id) - 1);
+ context->last_activity_time = get_current_timestamp();
+
+ return AI_OK;
+}
+
+ai_error_t ai_tts_stop(ai_services_context_t *context)
+{
+ if (context == NULL) {
+ return AI_ERROR_INVALID_PARAM;
+ }
+
+ if (!context->is_initialized) {
+ return AI_ERROR_NOT_INITIALIZED;
+ }
+
+ if (context->tts_state == TTS_STATE_IDLE) {
+ return AI_OK; // 已经停止
+ }
+
+ AI_LOGI("Stopping TTS");
+
+ /* 发送停止消息 */
+ char stop_message[] = "{\"type\":\"stop\",\"session_id\":\"%s\"}";
+ char json_buffer[JSON_BUFFER_SIZE];
+ snprintf(json_buffer, sizeof(json_buffer), stop_message, context->current_session_id);
+
+ ai_connection_manager_send_data(AI_SERVICE_TTS, json_buffer, strlen(json_buffer));
+
+ /* 更新状态 */
+ change_tts_state(context, TTS_STATE_IDLE);
+
+ return AI_OK;
+}
+
+tts_state_t ai_tts_get_state(ai_services_context_t *context)
+{
+ if (context == NULL || !context->is_initialized) {
+ return TTS_STATE_ERROR;
+ }
+
+ return context->tts_state;
+}
+
+/* ================================ 辅助函数实现 ================================ */
+
+void ai_asr_create_default_config(asr_config_t *config)
+{
+ if (config == NULL) {
+ return;
+ }
+
+ memset(config, 0, sizeof(asr_config_t));
+ config->enable_vad = true;
+ config->enable_punctuation = true;
+ config->enable_partial_results = true;
+ config->silence_timeout_ms = 3000; // 3秒静音超时
+ config->max_duration_ms = 30000; // 30秒最大录音时长
+ strncpy(config->language, "zh-CN", sizeof(config->language) - 1);
+}
+
+void ai_chat_create_default_config(chat_config_t *config)
+{
+ if (config == NULL) {
+ return;
+ }
+
+ memset(config, 0, sizeof(chat_config_t));
+ strncpy(config->model_name, "qwen-plus", sizeof(config->model_name) - 1);
+ config->temperature = 0.7f;
+ config->max_tokens = 512; // 适合LiteOS-M的较小值
+ config->top_p = 0.9f;
+ config->stream = true;
+ config->timeout_ms = 15000; // 15秒超时
+}
+
+void ai_tts_create_default_config(tts_config_t *config)
+{
+ if (config == NULL) {
+ return;
+ }
+
+ memset(config, 0, sizeof(tts_config_t));
+ config->voice_type = TTS_VOICE_XIAOYUN;
+ config->volume = 80; // 80%音量
+ config->speed = 50; // 正常语速
+ config->pitch = 50; // 正常音调
+ config->auto_play = true;
+ config->timeout_ms = 10000; // 10秒超时
+}
+
+void ai_services_generate_session_id(char *session_id, size_t buffer_size)
+{
+ if (session_id == NULL || buffer_size < 16) {
+ return;
+ }
+
+ /* 生成基于时间戳的会话ID */
+ uint32_t timestamp = get_current_timestamp();
+ uint32_t random = rand();
+
+ snprintf(session_id, buffer_size, "ai_%08x_%04x", timestamp, random & 0xFFFF);
+}
+
+const char* ai_tts_get_voice_name(tts_voice_type_t voice_type)
+{
+ if (voice_type >= TTS_VOICE_COUNT) {
+ return "unknown";
+ }
+
+ return g_voice_names[voice_type];
+}
+
+const char* ai_services_get_state_string(ai_service_type_t service_type, ai_services_context_t *context)
+{
+ if (context == NULL) {
+ return "UNKNOWN";
+ }
+
+ switch (service_type) {
+ case AI_SERVICE_ASR:
+ return (context->asr_state < sizeof(g_asr_state_names)/sizeof(g_asr_state_names[0])) ?
+ g_asr_state_names[context->asr_state] : "UNKNOWN";
+ case AI_SERVICE_CHAT:
+ return (context->chat_state < sizeof(g_chat_state_names)/sizeof(g_chat_state_names[0])) ?
+ g_chat_state_names[context->chat_state] : "UNKNOWN";
+ case AI_SERVICE_TTS:
+ return (context->tts_state < sizeof(g_tts_state_names)/sizeof(g_tts_state_names[0])) ?
+ g_tts_state_names[context->tts_state] : "UNKNOWN";
+ default:
+ return "UNKNOWN";
+ }
+}
+
+/* ================================ 内部函数实现 ================================ */
+
+static ai_error_t build_asr_start_message(const char *session_id, const asr_config_t *config, char *json_buffer, size_t buffer_size)
+{
+ if (session_id == NULL || config == NULL || json_buffer == NULL) {
+ return AI_ERROR_INVALID_PARAM;
+ }
+
+ /* 构建ASR启动消息 */
+ int ret = snprintf(json_buffer, buffer_size,
+ "{"
+ "\"type\":\"start\","
+ "\"session_id\":\"%s\","
+ "\"config\":{"
+ "\"language\":\"%s\","
+ "\"enable_vad\":%s,"
+ "\"enable_punctuation\":%s,"
+ "\"enable_partial_results\":%s,"
+ "\"silence_timeout_ms\":%d,"
+ "\"max_duration_ms\":%d"
+ "}"
+ "}",
+ session_id,
+ config->language,
+ config->enable_vad ? "true" : "false",
+ config->enable_punctuation ? "true" : "false",
+ config->enable_partial_results ? "true" : "false",
+ config->silence_timeout_ms,
+ config->max_duration_ms
+ );
+
+ if (ret < 0 || ret >= buffer_size) {
+ AI_LOGE("JSON buffer too small for ASR start message");
+ return AI_ERROR_BUFFER_OVERFLOW;
+ }
+
+ return AI_OK;
+}
+
+static ai_error_t build_chat_message(const char *message, const char *session_id, const chat_config_t *config, char *json_buffer, size_t buffer_size)
+{
+ if (message == NULL || session_id == NULL || config == NULL || json_buffer == NULL) {
+ return AI_ERROR_INVALID_PARAM;
+ }
+
+ /* 生成消息ID */
+ char message_id[MESSAGE_ID_LENGTH + 1];
+ generate_message_id(message_id, sizeof(message_id));
+
+ /* 构建Chat消息 */
+ int ret = snprintf(json_buffer, buffer_size,
+ "{"
+ "\"type\":\"chat\","
+ "\"session_id\":\"%s\","
+ "\"message_id\":\"%s\","
+ "\"message\":{"
+ "\"role\":\"user\","
+ "\"content\":\"%s\""
+ "},"
+ "\"config\":{"
+ "\"model\":\"%s\","
+ "\"temperature\":%.2f,"
+ "\"max_tokens\":%d,"
+ "\"top_p\":%.2f,"
+ "\"stream\":%s"
+ "}"
+ "}",
+ session_id,
+ message_id,
+ message,
+ config->model_name,
+ config->temperature,
+ config->max_tokens,
+ config->top_p,
+ config->stream ? "true" : "false"
+ );
+
+ if (ret < 0 || ret >= buffer_size) {
+ AI_LOGE("JSON buffer too small for chat message");
+ return AI_ERROR_BUFFER_OVERFLOW;
+ }
+
+ return AI_OK;
+}
+
+static ai_error_t build_tts_request(const char *text, const char *session_id, const tts_config_t *config, char *json_buffer, size_t buffer_size)
+{
+ if (text == NULL || session_id == NULL || config == NULL || json_buffer == NULL) {
+ return AI_ERROR_INVALID_PARAM;
+ }
+
+ /* 构建TTS请求 */
+ int ret = snprintf(json_buffer, buffer_size,
+ "{"
+ "\"type\":\"synthesize\","
+ "\"session_id\":\"%s\","
+ "\"text\":\"%s\","
+ "\"config\":{"
+ "\"voice\":\"%s\","
+ "\"volume\":%d,"
+ "\"speed\":%d,"
+ "\"pitch\":%d,"
+ "\"auto_play\":%s"
+ "}"
+ "}",
+ session_id,
+ text,
+ ai_tts_get_voice_name(config->voice_type),
+ config->volume,
+ config->speed,
+ config->pitch,
+ config->auto_play ? "true" : "false"
+ );
+
+ if (ret < 0 || ret >= buffer_size) {
+ AI_LOGE("JSON buffer too small for TTS request");
+ return AI_ERROR_BUFFER_OVERFLOW;
+ }
+
+ return AI_OK;
+}
+
+static void generate_message_id(char *message_id, size_t buffer_size)
+{
+ if (message_id == NULL || buffer_size < MESSAGE_ID_LENGTH + 1) {
+ return;
+ }
+
+ uint32_t timestamp = get_current_timestamp();
+ uint16_t random = rand() & 0xFFFF;
+
+ snprintf(message_id, buffer_size, "msg_%08x_%04x", timestamp, random);
+}
+
+static uint32_t get_current_timestamp(void)
+{
+#ifndef __TEST_MODE__
+ return (uint32_t)(osKernelGetTickCount() * 1000 / osKernelGetTickFreq());
+#else
+ return (uint32_t)time(NULL);
+#endif
+}
+
+static ai_error_t change_asr_state(ai_services_context_t *context, asr_state_t new_state)
+{
+ if (context == NULL) {
+ return AI_ERROR_INVALID_PARAM;
+ }
+
+ asr_state_t old_state = context->asr_state;
+ if (old_state != new_state) {
+ context->asr_state = new_state;
+
+ AI_LOGI("ASR state changed: %s -> %s",
+ g_asr_state_names[old_state],
+ g_asr_state_names[new_state]);
+
+ /* 调用状态回调 */
+ if (context->asr_state_cb != NULL) {
+ context->asr_state_cb(old_state, new_state, context->user_data);
+ }
+ }
+
+ return AI_OK;
+}
+
+static ai_error_t change_chat_state(ai_services_context_t *context, chat_state_t new_state)
+{
+ if (context == NULL) {
+ return AI_ERROR_INVALID_PARAM;
+ }
+
+ chat_state_t old_state = context->chat_state;
+ if (old_state != new_state) {
+ context->chat_state = new_state;
+
+ AI_LOGI("Chat state changed: %s -> %s",
+ g_chat_state_names[old_state],
+ g_chat_state_names[new_state]);
+
+ /* 调用状态回调 */
+ if (context->chat_state_cb != NULL) {
+ context->chat_state_cb(old_state, new_state, context->user_data);
+ }
+ }
+
+ return AI_OK;
+}
+
+static ai_error_t change_tts_state(ai_services_context_t *context, tts_state_t new_state)
+{
+ if (context == NULL) {
+ return AI_ERROR_INVALID_PARAM;
+ }
+
+ tts_state_t old_state = context->tts_state;
+ if (old_state != new_state) {
+ context->tts_state = new_state;
+
+ AI_LOGI("TTS state changed: %s -> %s",
+ g_tts_state_names[old_state],
+ g_tts_state_names[new_state]);
+
+ /* 调用状态回调 */
+ if (context->tts_state_cb != NULL) {
+ context->tts_state_cb(old_state, new_state, context->user_data);
+ }
+ }
+
+ return AI_OK;
+}
\ No newline at end of file
+++ /dev/null
-/*
- * Copyright (c) CompanyNameMagicTag. 2023-2023. All rights reserved.
- * Description: Enhanced ASR Server Implementation - 语音识别服务增强版
- * Author: AI Development Team
- * Create: 2024-12-28
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "asr_server.h"
-#include "ai_media.h"
-#include "../../../../application/wearable/ohos_deps/wearable_log.h"
-#include "../../../../../open_source/openharmony/third_party/cJSON/cJSON.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* ==================== 函数声明 ==================== */
-static ai_service_error_t asr_enhanced_stop(void);
-
-/* ==================== 内部宏定义 ==================== */
-
-#define ASR_LOG_TAG "ASR_ENHANCED"
-#define ASR_AUDIO_BUFFER_SIZE 4096
-#define ASR_RECOGNITION_TIMEOUT_MS 30000
-
-/* ==================== 内部结构体定义 ==================== */
-
-/**
- * @brief ASR识别状态
- */
-typedef enum {
- ASR_RECOGNITION_STATE_IDLE = 0,
- ASR_RECOGNITION_STATE_STARTING,
- ASR_RECOGNITION_STATE_ACTIVE,
- ASR_RECOGNITION_STATE_STOPPING,
- ASR_RECOGNITION_STATE_STOPPED
-} asr_recognition_state_t;
-
-/**
- * @brief 增强的ASR上下文
- */
-typedef struct {
- asr_server_context_t base; // 基础ASR上下文
-
- /* 连接管理 */
- bool websocket_connected; // WebSocket连接状态
- bool connection_persistent; // 持久连接标志
-
- /* 录音服务管理 */
- bool recording_service_active; // 录音服务状态
- bool recording_service_persistent; // 录音服务持久化标志
-
- /* 上传控制 */
- bool upload_control_enabled; // 上传控制开关
- asr_recognition_state_t recognition_state; // 识别状态
- char current_session_id[64]; // 当前会话ID
-
- /* 消息解析 */
- bool transcription_started; // 转录是否已开始
- osMessageQueueId_t audio_queue; // 音频数据队列
- osThreadId_t upload_thread; // 上传线程
-
- /* 事件管理 */
- osTimerId_t recognition_timer; // 识别超时定时器
-
- /* 同步控制 */
- osMutexId_t state_mutex;
- osSemaphoreId_t upload_sem;
-
- /* 回调函数 */
- void (*on_transcription_started)(void *user_data, const char *session_id);
- void (*on_recognition_partial)(void *user_data, const char *session_id, const char *text, float confidence);
- void (*on_recognition_final)(void *user_data, const char *session_id, const char *text, float confidence);
- void (*on_transcription_completed)(void *user_data, const char *session_id);
- void (*on_error)(void *user_data, int error_code, const char *error_msg);
- void *user_data;
-} asr_enhanced_context_t;
-
-/* ==================== 全局变量 ==================== */
-
-static asr_enhanced_context_t *g_asr_enhanced_context = NULL;
-
-/* ==================== 内部函数声明 ==================== */
-
-static void asr_enhanced_upload_thread(void *arg);
-static void asr_enhanced_recognition_timeout_callback(void *arg);
-static void asr_enhanced_record_callback(uint8_t *data, uint32_t size);
-static ai_service_error_t asr_enhanced_parse_recognition_message(asr_enhanced_context_t *context,
- const char *json_data);
-static void asr_enhanced_set_recognition_state(asr_enhanced_context_t *context,
- asr_recognition_state_t new_state);
-static void asr_enhanced_on_websocket_message(void *context, const char *data, size_t length);
-static void asr_enhanced_on_websocket_connected(void *context);
-static void asr_enhanced_on_websocket_disconnected(void *context);
-static void asr_enhanced_on_websocket_error(void *context, int error_code, const char *error_msg);
-
-/* ==================== 公共接口实现 ==================== */
-
-/**
- * @brief 初始化增强ASR服务
- */
-ai_service_error_t asr_enhanced_init(const ai_service_config_t *config,
- const asr_audio_config_t *audio_config,
- const asr_recognition_config_t *recognition_config)
-{
- if (config == NULL || audio_config == NULL || recognition_config == NULL) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Invalid parameters", ASR_LOG_TAG);
- return AI_SERVICE_ERROR_INVALID_PARAM;
- }
-
- if (g_asr_enhanced_context != NULL) {
- WEARABLE_LOGW(WEARABLE_LOG_MODULE_APP, "[%s] Already initialized", ASR_LOG_TAG);
- return AI_SERVICE_ERROR_ALREADY_CONNECTED;
- }
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Initializing enhanced ASR service", ASR_LOG_TAG);
-
- // 分配上下文内存
- g_asr_enhanced_context = (asr_enhanced_context_t *)malloc(sizeof(asr_enhanced_context_t));
- if (g_asr_enhanced_context == NULL) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Failed to allocate context", ASR_LOG_TAG);
- return AI_SERVICE_ERROR_MEMORY_ALLOC;
- }
-
- memset(g_asr_enhanced_context, 0, sizeof(asr_enhanced_context_t));
-
- // 初始化基础ASR服务
- ai_service_error_t ret = asr_server_init(&g_asr_enhanced_context->base,
- config->server_url,
- audio_config,
- recognition_config);
- if (ret != AI_SERVICE_OK) {
- free(g_asr_enhanced_context);
- g_asr_enhanced_context = NULL;
- return ret;
- }
-
- // 复制配置
- memcpy(&g_asr_enhanced_context->base.audio_config, audio_config, sizeof(asr_audio_config_t));
- memcpy(&g_asr_enhanced_context->base.recognition_config, recognition_config, sizeof(asr_recognition_config_t));
-
- // 初始化状态
- g_asr_enhanced_context->websocket_connected = false;
- g_asr_enhanced_context->connection_persistent = true;
- g_asr_enhanced_context->recording_service_active = false;
- g_asr_enhanced_context->recording_service_persistent = true;
- g_asr_enhanced_context->upload_control_enabled = false;
- g_asr_enhanced_context->recognition_state = ASR_RECOGNITION_STATE_IDLE;
- g_asr_enhanced_context->transcription_started = false;
-
- // 创建互斥锁和信号量
- g_asr_enhanced_context->state_mutex = osMutexNew(NULL);
- if (g_asr_enhanced_context->state_mutex == NULL) {
- asr_server_destroy(&g_asr_enhanced_context->base);
- free(g_asr_enhanced_context);
- g_asr_enhanced_context = NULL;
- return AI_SERVICE_ERROR_INTERNAL;
- }
-
- g_asr_enhanced_context->upload_sem = osSemaphoreNew(1, 0, NULL);
- if (g_asr_enhanced_context->upload_sem == NULL) {
- osMutexDelete(g_asr_enhanced_context->state_mutex);
- asr_server_destroy(&g_asr_enhanced_context->base);
- free(g_asr_enhanced_context);
- g_asr_enhanced_context = NULL;
- return AI_SERVICE_ERROR_INTERNAL;
- }
-
- // 创建音频队列
- g_asr_enhanced_context->audio_queue = osMessageQueueNew(32, ASR_AUDIO_BUFFER_SIZE, NULL);
- if (g_asr_enhanced_context->audio_queue == NULL) {
- osSemaphoreDelete(g_asr_enhanced_context->upload_sem);
- osMutexDelete(g_asr_enhanced_context->state_mutex);
- asr_server_destroy(&g_asr_enhanced_context->base);
- free(g_asr_enhanced_context);
- g_asr_enhanced_context = NULL;
- return AI_SERVICE_ERROR_INTERNAL;
- }
-
- // 创建识别超时定时器
- g_asr_enhanced_context->recognition_timer = osTimerNew(asr_enhanced_recognition_timeout_callback,
- osTimerOnce,
- g_asr_enhanced_context,
- NULL);
- if (g_asr_enhanced_context->recognition_timer == NULL) {
- osMessageQueueDelete(g_asr_enhanced_context->audio_queue);
- osSemaphoreDelete(g_asr_enhanced_context->upload_sem);
- osMutexDelete(g_asr_enhanced_context->state_mutex);
- asr_server_destroy(&g_asr_enhanced_context->base);
- free(g_asr_enhanced_context);
- g_asr_enhanced_context = NULL;
- return AI_SERVICE_ERROR_INTERNAL;
- }
-
- // 创建上传线程
- osThreadAttr_t thread_attr = {
- .name = "asr_upload",
- .stack_size = 8192,
- .priority = osPriorityNormal
- };
-
- g_asr_enhanced_context->upload_thread = osThreadNew(asr_enhanced_upload_thread,
- g_asr_enhanced_context,
- &thread_attr);
- if (g_asr_enhanced_context->upload_thread == NULL) {
- osTimerDelete(g_asr_enhanced_context->recognition_timer);
- osMessageQueueDelete(g_asr_enhanced_context->audio_queue);
- osSemaphoreDelete(g_asr_enhanced_context->upload_sem);
- osMutexDelete(g_asr_enhanced_context->state_mutex);
- asr_server_destroy(&g_asr_enhanced_context->base);
- free(g_asr_enhanced_context);
- g_asr_enhanced_context = NULL;
- return AI_SERVICE_ERROR_INTERNAL;
- }
-
- // 设置WebSocket回调
- ai_service_set_callbacks(&g_asr_enhanced_context->base.base,
- asr_enhanced_on_websocket_connected,
- asr_enhanced_on_websocket_disconnected,
- asr_enhanced_on_websocket_message,
- asr_enhanced_on_websocket_error);
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Enhanced ASR service initialized", ASR_LOG_TAG);
- return AI_SERVICE_OK;
-}
-
-/**
- * @brief 销毁增强ASR服务
- */
-ai_service_error_t asr_enhanced_destroy(void)
-{
- if (g_asr_enhanced_context == NULL) {
- return AI_SERVICE_OK;
- }
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Destroying enhanced ASR service", ASR_LOG_TAG);
-
- // 停止服务
- asr_enhanced_stop();
-
- // 终止上传线程
- if (g_asr_enhanced_context->upload_thread != NULL) {
- osThreadTerminate(g_asr_enhanced_context->upload_thread);
- }
-
- // 清理资源
- if (g_asr_enhanced_context->recognition_timer != NULL) {
- osTimerDelete(g_asr_enhanced_context->recognition_timer);
- }
-
- if (g_asr_enhanced_context->audio_queue != NULL) {
- osMessageQueueDelete(g_asr_enhanced_context->audio_queue);
- }
-
- if (g_asr_enhanced_context->upload_sem != NULL) {
- osSemaphoreDelete(g_asr_enhanced_context->upload_sem);
- }
-
- if (g_asr_enhanced_context->state_mutex != NULL) {
- osMutexDelete(g_asr_enhanced_context->state_mutex);
- }
-
- // 销毁基础ASR服务
- asr_server_destroy(&g_asr_enhanced_context->base);
-
- // 释放上下文
- free(g_asr_enhanced_context);
- g_asr_enhanced_context = NULL;
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Enhanced ASR service destroyed", ASR_LOG_TAG);
- return AI_SERVICE_OK;
-}
-
-/**
- * @brief 启动ASR服务
- */
-ai_service_error_t asr_enhanced_start(void)
-{
- if (g_asr_enhanced_context == NULL) {
- return AI_SERVICE_ERROR_NOT_CONNECTED;
- }
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Starting ASR service", ASR_LOG_TAG);
-
- // 启动基础ASR服务（建立WebSocket连接）
- ai_service_error_t ret = asr_server_start(&g_asr_enhanced_context->base);
- if (ret != AI_SERVICE_OK) {
- return ret;
- }
-
- osMutexAcquire(g_asr_enhanced_context->state_mutex, osWaitForever);
-
- // 启动录音服务（如果启用持久化）
- if (g_asr_enhanced_context->recording_service_persistent &&
- !g_asr_enhanced_context->recording_service_active) {
-
- ai_media_record_start((uint8_t*)"pcm");
- if (1) { // ai_media_record_start returns void, assume success
- g_asr_enhanced_context->recording_service_active = true;
- ai_media_set_record_callback(asr_enhanced_record_callback);
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Recording service started", ASR_LOG_TAG);
- } else {
- WEARABLE_LOGW(WEARABLE_LOG_MODULE_APP, "[%s] Failed to start recording service", ASR_LOG_TAG);
- }
- }
-
- osMutexRelease(g_asr_enhanced_context->state_mutex);
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] ASR service started", ASR_LOG_TAG);
- return AI_SERVICE_OK;
-}
-
-/**
- * @brief 停止ASR服务
- */
-ai_service_error_t asr_enhanced_stop(void)
-{
- if (g_asr_enhanced_context == NULL) {
- return AI_SERVICE_OK;
- }
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Stopping ASR service", ASR_LOG_TAG);
-
- osMutexAcquire(g_asr_enhanced_context->state_mutex, osWaitForever);
-
- // 停止识别
- if (g_asr_enhanced_context->recognition_state != ASR_RECOGNITION_STATE_IDLE) {
- asr_enhanced_set_recognition_state(g_asr_enhanced_context, ASR_RECOGNITION_STATE_STOPPING);
- g_asr_enhanced_context->upload_control_enabled = false;
- }
-
- // 停止录音服务（如果不是持久化的）
- if (!g_asr_enhanced_context->recording_service_persistent &&
- g_asr_enhanced_context->recording_service_active) {
- ai_media_record_stop();
- g_asr_enhanced_context->recording_service_active = false;
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Recording service stopped", ASR_LOG_TAG);
- }
-
- // 停止超时定时器
- osTimerStop(g_asr_enhanced_context->recognition_timer);
-
- osMutexRelease(g_asr_enhanced_context->state_mutex);
-
- // 停止基础ASR服务（如果不是持久连接）
- if (!g_asr_enhanced_context->connection_persistent) {
- asr_server_stop(&g_asr_enhanced_context->base);
- }
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] ASR service stopped", ASR_LOG_TAG);
- return AI_SERVICE_OK;
-}
-
-/**
- * @brief 开始识别
- */
-ai_service_error_t asr_enhanced_start_recognition(const char *session_id)
-{
- if (g_asr_enhanced_context == NULL || session_id == NULL) {
- return AI_SERVICE_ERROR_INVALID_PARAM;
- }
-
- osMutexAcquire(g_asr_enhanced_context->state_mutex, osWaitForever);
-
- if (g_asr_enhanced_context->recognition_state != ASR_RECOGNITION_STATE_IDLE) {
- osMutexRelease(g_asr_enhanced_context->state_mutex);
- WEARABLE_LOGW(WEARABLE_LOG_MODULE_APP, "[%s] Recognition already active", ASR_LOG_TAG);
- return AI_SERVICE_ERROR_ALREADY_CONNECTED;
- }
-
- if (!g_asr_enhanced_context->websocket_connected) {
- osMutexRelease(g_asr_enhanced_context->state_mutex);
- WEARABLE_LOGW(WEARABLE_LOG_MODULE_APP, "[%s] WebSocket not connected", ASR_LOG_TAG);
- return AI_SERVICE_ERROR_NOT_CONNECTED;
- }
-
- // 设置会话ID
- strncpy(g_asr_enhanced_context->current_session_id, session_id,
- sizeof(g_asr_enhanced_context->current_session_id) - 1);
- g_asr_enhanced_context->current_session_id[sizeof(g_asr_enhanced_context->current_session_id) - 1] = '\0';
-
- // 启用上传控制
- g_asr_enhanced_context->upload_control_enabled = true;
- g_asr_enhanced_context->transcription_started = false;
- asr_enhanced_set_recognition_state(g_asr_enhanced_context, ASR_RECOGNITION_STATE_STARTING);
-
- // 启动识别超时定时器
- osTimerStart(g_asr_enhanced_context->recognition_timer, ASR_RECOGNITION_TIMEOUT_MS);
-
- osMutexRelease(g_asr_enhanced_context->state_mutex);
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Recognition started: %s", ASR_LOG_TAG, session_id);
- return AI_SERVICE_OK;
-}
-
-/**
- * @brief 停止识别
- */
-ai_service_error_t asr_enhanced_stop_recognition(void)
-{
- if (g_asr_enhanced_context == NULL) {
- return AI_SERVICE_ERROR_NOT_CONNECTED;
- }
-
- osMutexAcquire(g_asr_enhanced_context->state_mutex, osWaitForever);
-
- if (g_asr_enhanced_context->recognition_state == ASR_RECOGNITION_STATE_IDLE) {
- osMutexRelease(g_asr_enhanced_context->state_mutex);
- return AI_SERVICE_OK;
- }
-
- // 禁用上传控制
- g_asr_enhanced_context->upload_control_enabled = false;
- asr_enhanced_set_recognition_state(g_asr_enhanced_context, ASR_RECOGNITION_STATE_STOPPING);
-
- // 停止超时定时器
- osTimerStop(g_asr_enhanced_context->recognition_timer);
-
- osMutexRelease(g_asr_enhanced_context->state_mutex);
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Recognition stopped", ASR_LOG_TAG);
- return AI_SERVICE_OK;
-}
-
-/**
- * @brief 设置上传控制
- */
-ai_service_error_t asr_enhanced_set_upload_control(bool enabled)
-{
- if (g_asr_enhanced_context == NULL) {
- return AI_SERVICE_ERROR_NOT_CONNECTED;
- }
-
- osMutexAcquire(g_asr_enhanced_context->state_mutex, osWaitForever);
- g_asr_enhanced_context->upload_control_enabled = enabled;
- osMutexRelease(g_asr_enhanced_context->state_mutex);
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Upload control %s",
- ASR_LOG_TAG, enabled ? "enabled" : "disabled");
- return AI_SERVICE_OK;
-}
-
-/**
- * @brief 设置录音服务持久化
- */
-ai_service_error_t asr_enhanced_set_recording_persistent(bool persistent)
-{
- if (g_asr_enhanced_context == NULL) {
- return AI_SERVICE_ERROR_NOT_CONNECTED;
- }
-
- osMutexAcquire(g_asr_enhanced_context->state_mutex, osWaitForever);
- g_asr_enhanced_context->recording_service_persistent = persistent;
- osMutexRelease(g_asr_enhanced_context->state_mutex);
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Recording service persistent: %s",
- ASR_LOG_TAG, persistent ? "enabled" : "disabled");
- return AI_SERVICE_OK;
-}
-
-/**
- * @brief 设置连接持久化
- */
-ai_service_error_t asr_enhanced_set_connection_persistent(bool persistent)
-{
- if (g_asr_enhanced_context == NULL) {
- return AI_SERVICE_ERROR_NOT_CONNECTED;
- }
-
- osMutexAcquire(g_asr_enhanced_context->state_mutex, osWaitForever);
- g_asr_enhanced_context->connection_persistent = persistent;
- osMutexRelease(g_asr_enhanced_context->state_mutex);
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Connection persistent: %s",
- ASR_LOG_TAG, persistent ? "enabled" : "disabled");
- return AI_SERVICE_OK;
-}
-
-/**
- * @brief 设置回调函数
- */
-void asr_enhanced_set_callbacks(void (*on_transcription_started)(void *user_data, const char *session_id),
- void (*on_recognition_partial)(void *user_data, const char *session_id, const char *text, float confidence),
- void (*on_recognition_final)(void *user_data, const char *session_id, const char *text, float confidence),
- void (*on_transcription_completed)(void *user_data, const char *session_id),
- void (*on_error)(void *user_data, int error_code, const char *error_msg),
- void *user_data)
-{
- if (g_asr_enhanced_context == NULL) {
- return;
- }
-
- osMutexAcquire(g_asr_enhanced_context->state_mutex, osWaitForever);
- g_asr_enhanced_context->on_transcription_started = on_transcription_started;
- g_asr_enhanced_context->on_recognition_partial = on_recognition_partial;
- g_asr_enhanced_context->on_recognition_final = on_recognition_final;
- g_asr_enhanced_context->on_transcription_completed = on_transcription_completed;
- g_asr_enhanced_context->on_error = on_error;
- g_asr_enhanced_context->user_data = user_data;
- osMutexRelease(g_asr_enhanced_context->state_mutex);
-}
-
-/* ==================== 内部函数实现 ==================== */
-
-/**
- * @brief 上传线程
- */
-static void asr_enhanced_upload_thread(void *arg)
-{
- asr_enhanced_context_t *context = (asr_enhanced_context_t *)arg;
- uint8_t audio_buffer[ASR_AUDIO_BUFFER_SIZE];
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Upload thread started", ASR_LOG_TAG);
-
- while (true) {
- // 等待上传信号
- osSemaphoreAcquire(context->upload_sem, osWaitForever);
-
- // 从音频队列获取数据
- osStatus_t status = osMessageQueueGet(context->audio_queue, audio_buffer, NULL, 0);
- if (status == osOK) {
- osMutexAcquire(context->state_mutex, osWaitForever);
-
- // 检查上传控制和连接状态
- bool can_upload = context->upload_control_enabled &&
- context->websocket_connected &&
- context->transcription_started;
-
- osMutexRelease(context->state_mutex);
-
- if (can_upload) {
- // 发送音频数据到服务器
- ai_service_send_data(&context->base.base, (const char*)audio_buffer, ASR_AUDIO_BUFFER_SIZE);
- }
- }
- }
-}
-
-/**
- * @brief 识别超时回调
- */
-static void asr_enhanced_recognition_timeout_callback(void *arg)
-{
- asr_enhanced_context_t *context = (asr_enhanced_context_t *)arg;
-
- WEARABLE_LOGW(WEARABLE_LOG_MODULE_APP, "[%s] Recognition timeout", ASR_LOG_TAG);
-
- osMutexAcquire(context->state_mutex, osWaitForever);
-
- if (context->recognition_state == ASR_RECOGNITION_STATE_ACTIVE) {
- asr_enhanced_set_recognition_state(context, ASR_RECOGNITION_STATE_STOPPED);
- context->upload_control_enabled = false;
-
- // 调用错误回调
- if (context->on_error != NULL) {
- context->on_error(context->user_data, AI_SERVICE_ERROR_TIMEOUT, "Recognition timeout");
- }
- }
-
- osMutexRelease(context->state_mutex);
-}
-
-/**
- * @brief 录音回调函数
- */
-static void asr_enhanced_record_callback(uint8_t *data, uint32_t size)
-{
- if (g_asr_enhanced_context == NULL || data == NULL || size == 0) {
- return;
- }
-
- // 如果数据大小超过缓冲区，截断
- uint32_t copy_size = (size > ASR_AUDIO_BUFFER_SIZE) ? ASR_AUDIO_BUFFER_SIZE : size;
-
- // 发送到音频队列
- osStatus_t status = osMessageQueuePut(g_asr_enhanced_context->audio_queue, data, 0, 0);
- if (status == osOK) {
- // 通知上传线程
- osSemaphoreRelease(g_asr_enhanced_context->upload_sem);
- }
-}
-
-/**
- * @brief 解析识别消息
- */
-static ai_service_error_t asr_enhanced_parse_recognition_message(asr_enhanced_context_t *context,
- const char *json_data)
-{
- cJSON *root = cJSON_Parse(json_data);
- if (root == NULL) {
- return AI_SERVICE_ERROR_INVALID_PARAM;
- }
-
- cJSON *event_obj = cJSON_GetObjectItem(root, "event");
- if (event_obj == NULL || !cJSON_IsString(event_obj)) {
- cJSON_Delete(root);
- return AI_SERVICE_ERROR_INVALID_PARAM;
- }
-
- const char *event = cJSON_GetStringValue(event_obj);
-
- if (strcmp(event, "TranscriptionStarted") == 0) {
- // 转录开始
- osMutexAcquire(context->state_mutex, osWaitForever);
- context->transcription_started = true;
- asr_enhanced_set_recognition_state(context, ASR_RECOGNITION_STATE_ACTIVE);
- osMutexRelease(context->state_mutex);
-
- // 调用开始回调
- if (context->on_transcription_started != NULL) {
- context->on_transcription_started(context->user_data, context->current_session_id);
- }
-
- } else if (strcmp(event, "Changed") == 0) {
- // 识别中间结果
- cJSON *result_obj = cJSON_GetObjectItem(root, "result");
- if (result_obj != NULL) {
- cJSON *text_obj = cJSON_GetObjectItem(result_obj, "result");
- cJSON *is_end_obj = cJSON_GetObjectItem(result_obj, "is_end");
-
- if (text_obj != NULL && cJSON_IsString(text_obj)) {
- const char *text = cJSON_GetStringValue(text_obj);
- bool is_end = cJSON_IsTrue(is_end_obj);
-
- // 调用部分结果回调
- if (context->on_recognition_partial != NULL) {
- context->on_recognition_partial(context->user_data,
- context->current_session_id,
- text, 0.0f);
- }
- }
- }
-
- } else if (strcmp(event, "SentenceEnd") == 0) {
- // 句子结束
- cJSON *result_obj = cJSON_GetObjectItem(root, "result");
- if (result_obj != NULL) {
- cJSON *text_obj = cJSON_GetObjectItem(result_obj, "result");
- cJSON *is_end_obj = cJSON_GetObjectItem(result_obj, "is_end");
-
- if (text_obj != NULL && cJSON_IsString(text_obj) && cJSON_IsTrue(is_end_obj)) {
- const char *text = cJSON_GetStringValue(text_obj);
-
- // 调用最终结果回调
- if (context->on_recognition_final != NULL) {
- context->on_recognition_final(context->user_data,
- context->current_session_id,
- text, 1.0f);
- }
- }
- }
-
- } else if (strcmp(event, "TranscriptionCompleted") == 0) {
- // 转录完成
- osMutexAcquire(context->state_mutex, osWaitForever);
- asr_enhanced_set_recognition_state(context, ASR_RECOGNITION_STATE_STOPPED);
- context->upload_control_enabled = false;
- osTimerStop(context->recognition_timer);
- osMutexRelease(context->state_mutex);
-
- // 调用完成回调
- if (context->on_transcription_completed != NULL) {
- context->on_transcription_completed(context->user_data, context->current_session_id);
- }
- }
-
- cJSON_Delete(root);
- return AI_SERVICE_OK;
-}
-
-/**
- * @brief 设置识别状态
- */
-static void asr_enhanced_set_recognition_state(asr_enhanced_context_t *context,
- asr_recognition_state_t new_state)
-{
- asr_recognition_state_t old_state = context->recognition_state;
- context->recognition_state = new_state;
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Recognition state changed: %d -> %d",
- ASR_LOG_TAG, old_state, new_state);
-}
-
-/* ==================== WebSocket回调函数 ==================== */
-
-static void asr_enhanced_on_websocket_connected(void *context)
-{
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] WebSocket connected", ASR_LOG_TAG);
-
- if (g_asr_enhanced_context != NULL) {
- osMutexAcquire(g_asr_enhanced_context->state_mutex, osWaitForever);
- g_asr_enhanced_context->websocket_connected = true;
- osMutexRelease(g_asr_enhanced_context->state_mutex);
- }
-}
-
-static void asr_enhanced_on_websocket_disconnected(void *context)
-{
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] WebSocket disconnected", ASR_LOG_TAG);
-
- if (g_asr_enhanced_context != NULL) {
- osMutexAcquire(g_asr_enhanced_context->state_mutex, osWaitForever);
- g_asr_enhanced_context->websocket_connected = false;
- g_asr_enhanced_context->transcription_started = false;
-
- // 如果是持久连接，尝试重连
- if (g_asr_enhanced_context->connection_persistent) {
- ai_service_connect(&g_asr_enhanced_context->base.base);
- }
-
- osMutexRelease(g_asr_enhanced_context->state_mutex);
- }
-}
-
-static void asr_enhanced_on_websocket_message(void *context, const char *data, size_t length)
-{
- if (g_asr_enhanced_context == NULL || data == NULL || length == 0) {
- return;
- }
-
- // 检查是否为JSON数据
- if (data[0] == '{') {
- // JSON消息，解析识别结果
- asr_enhanced_parse_recognition_message(g_asr_enhanced_context, data);
- } else {
- // 二进制数据，暂时忽略
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[%s] Received binary data: %zu bytes", ASR_LOG_TAG, length);
- }
-}
-
-static void asr_enhanced_on_websocket_error(void *context, int error_code, const char *error_msg)
-{
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] WebSocket error: %d - %s",
- ASR_LOG_TAG, error_code, error_msg ? error_msg : "Unknown");
-
- if (g_asr_enhanced_context != NULL) {
- osMutexAcquire(g_asr_enhanced_context->state_mutex, osWaitForever);
-
- g_asr_enhanced_context->websocket_connected = false;
- asr_enhanced_set_recognition_state(g_asr_enhanced_context, ASR_RECOGNITION_STATE_IDLE);
-
- // 调用错误回调
- if (g_asr_enhanced_context->on_error != NULL) {
- g_asr_enhanced_context->on_error(g_asr_enhanced_context->user_data,
- error_code, error_msg);
- }
-
- osMutexRelease(g_asr_enhanced_context->state_mutex);
- }
-}
-
-#ifdef __cplusplus
-}
-#endif
\ No newline at end of file
+++ /dev/null
-/*
- * Copyright (c) CompanyNameMagicTag. 2023-2023. All rights reserved.
- * Description: Enhanced Chat Server Implementation - 对话服务增强版
- * Author: AI Development Team
- * Create: 2024-12-28
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "chat_server.h"
-#include "../../../../application/wearable/ohos_deps/wearable_log.h"
-#include "../../../../../open_source/openharmony/third_party/cJSON/cJSON.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* ==================== 函数声明 ==================== */
-static ai_service_error_t chat_enhanced_stop(void);
-
-/* ==================== 内部宏定义 ==================== */
-
-#define CHAT_LOG_TAG "CHAT_ENHANCED"
-#define CHAT_MAX_HISTORY_SIZE 50
-#define CHAT_MAX_RESPONSE_BUFFER 8192
-#define CHAT_INTERRUPT_TIMEOUT_MS 5000
-
-/* ==================== 内部结构体定义 ==================== */
-
-/**
- * @brief Chat对话状态
- */
-typedef enum {
- CHAT_STATE_IDLE = 0,
- CHAT_STATE_SENDING,
- CHAT_STATE_RECEIVING,
- CHAT_STATE_INTERRUPTED
-} chat_conversation_state_t;
-
-/**
- * @brief Chat消息历史记录
- */
-typedef struct chat_history_node {
- chat_message_t message;
- struct chat_history_node *next;
-} chat_history_node_t;
-
-/**
- * @brief 增强的Chat上下文
- */
-typedef struct {
- chat_server_context_t base; // 基础Chat上下文
-
- /* 对话管理 */
- chat_conversation_state_t state;
- char current_session_id[64];
- chat_history_node_t *history_head;
- uint32_t history_count;
-
- /* 连续对话支持 */
- bool continuous_mode;
- uint32_t last_message_time;
- osTimerId_t timeout_timer;
-
- /* 打断机制 */
- bool interrupt_requested;
- osThreadId_t response_thread;
-
- /* 响应缓冲 */
- char response_buffer[CHAT_MAX_RESPONSE_BUFFER];
- size_t response_length;
- bool response_complete;
-
- /* 同步控制 */
- osMutexId_t state_mutex;
- osSemaphoreId_t response_sem;
-
- /* 回调函数 */
- void (*on_response_start)(void *user_data, const char *session_id);
- void (*on_response_partial)(void *user_data, const char *session_id, const char *content);
- void (*on_response_end)(void *user_data, const char *session_id, const char *full_content);
- void (*on_error)(void *user_data, int error_code, const char *error_msg);
- void *user_data;
-} chat_enhanced_context_t;
-
-/* ==================== 全局变量 ==================== */
-
-static chat_enhanced_context_t *g_chat_enhanced_context = NULL;
-
-/* ==================== 内部函数声明 ==================== */
-
-static void chat_enhanced_response_thread(void *arg);
-static void chat_enhanced_timeout_callback(void *arg);
-static ai_service_error_t chat_enhanced_send_message_internal(chat_enhanced_context_t *context,
- const chat_message_t *message);
-static ai_service_error_t chat_enhanced_parse_response(chat_enhanced_context_t *context,
- const char *json_data);
-static void chat_enhanced_add_to_history(chat_enhanced_context_t *context,
- const chat_message_t *message);
-static void chat_enhanced_clear_history(chat_enhanced_context_t *context);
-static void chat_enhanced_set_state(chat_enhanced_context_t *context,
- chat_conversation_state_t new_state);
-static void chat_enhanced_on_websocket_message(void *context, const char *data, size_t length);
-static void chat_enhanced_on_websocket_connected(void *context);
-static void chat_enhanced_on_websocket_disconnected(void *context);
-static void chat_enhanced_on_websocket_error(void *context, int error_code, const char *error_msg);
-
-/* ==================== 公共接口实现 ==================== */
-
-/**
- * @brief 初始化增强Chat服务
- */
-ai_service_error_t chat_enhanced_init(const ai_service_config_t *config,
- const chat_model_config_t *model_config)
-{
- if (config == NULL || model_config == NULL) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Invalid parameters", CHAT_LOG_TAG);
- return AI_SERVICE_ERROR_INVALID_PARAM;
- }
-
- if (g_chat_enhanced_context != NULL) {
- WEARABLE_LOGW(WEARABLE_LOG_MODULE_APP, "[%s] Already initialized", CHAT_LOG_TAG);
- return AI_SERVICE_ERROR_ALREADY_CONNECTED;
- }
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Initializing enhanced Chat service", CHAT_LOG_TAG);
-
- // 分配上下文内存
- g_chat_enhanced_context = (chat_enhanced_context_t *)malloc(sizeof(chat_enhanced_context_t));
- if (g_chat_enhanced_context == NULL) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Failed to allocate context", CHAT_LOG_TAG);
- return AI_SERVICE_ERROR_MEMORY_ALLOC;
- }
-
- memset(g_chat_enhanced_context, 0, sizeof(chat_enhanced_context_t));
-
- // 初始化基础Chat服务
- ai_service_error_t ret = chat_server_init(&g_chat_enhanced_context->base,
- config->server_url,
- model_config);
- if (ret != AI_SERVICE_OK) {
- free(g_chat_enhanced_context);
- g_chat_enhanced_context = NULL;
- return ret;
- }
-
- // 复制模型配置
- memcpy(&g_chat_enhanced_context->base.model_config, model_config, sizeof(chat_model_config_t));
-
- // 初始化状态
- g_chat_enhanced_context->state = CHAT_STATE_IDLE;
- g_chat_enhanced_context->continuous_mode = true;
- g_chat_enhanced_context->history_head = NULL;
- g_chat_enhanced_context->history_count = 0;
-
- // 创建互斥锁和信号量
- g_chat_enhanced_context->state_mutex = osMutexNew(NULL);
- if (g_chat_enhanced_context->state_mutex == NULL) {
- chat_server_destroy(&g_chat_enhanced_context->base);
- free(g_chat_enhanced_context);
- g_chat_enhanced_context = NULL;
- return AI_SERVICE_ERROR_INTERNAL;
- }
-
- g_chat_enhanced_context->response_sem = osSemaphoreNew(1, 0, NULL);
- if (g_chat_enhanced_context->response_sem == NULL) {
- osMutexDelete(g_chat_enhanced_context->state_mutex);
- chat_server_destroy(&g_chat_enhanced_context->base);
- free(g_chat_enhanced_context);
- g_chat_enhanced_context = NULL;
- return AI_SERVICE_ERROR_INTERNAL;
- }
-
- // 创建超时定时器
- g_chat_enhanced_context->timeout_timer = osTimerNew(chat_enhanced_timeout_callback,
- osTimerOnce,
- g_chat_enhanced_context,
- NULL);
- if (g_chat_enhanced_context->timeout_timer == NULL) {
- osSemaphoreDelete(g_chat_enhanced_context->response_sem);
- osMutexDelete(g_chat_enhanced_context->state_mutex);
- chat_server_destroy(&g_chat_enhanced_context->base);
- free(g_chat_enhanced_context);
- g_chat_enhanced_context = NULL;
- return AI_SERVICE_ERROR_INTERNAL;
- }
-
- // 创建响应处理线程
- osThreadAttr_t thread_attr = {
- .name = "chat_response",
- .stack_size = 8192,
- .priority = osPriorityNormal
- };
-
- g_chat_enhanced_context->response_thread = osThreadNew(chat_enhanced_response_thread,
- g_chat_enhanced_context,
- &thread_attr);
- if (g_chat_enhanced_context->response_thread == NULL) {
- osTimerDelete(g_chat_enhanced_context->timeout_timer);
- osSemaphoreDelete(g_chat_enhanced_context->response_sem);
- osMutexDelete(g_chat_enhanced_context->state_mutex);
- chat_server_destroy(&g_chat_enhanced_context->base);
- free(g_chat_enhanced_context);
- g_chat_enhanced_context = NULL;
- return AI_SERVICE_ERROR_INTERNAL;
- }
-
- // 设置WebSocket回调
- ai_service_set_callbacks(&g_chat_enhanced_context->base.base,
- chat_enhanced_on_websocket_connected,
- chat_enhanced_on_websocket_disconnected,
- chat_enhanced_on_websocket_message,
- chat_enhanced_on_websocket_error);
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Enhanced Chat service initialized", CHAT_LOG_TAG);
- return AI_SERVICE_OK;
-}
-
-/**
- * @brief 销毁增强Chat服务
- */
-ai_service_error_t chat_enhanced_destroy(void)
-{
- if (g_chat_enhanced_context == NULL) {
- return AI_SERVICE_OK;
- }
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Destroying enhanced Chat service", CHAT_LOG_TAG);
-
- // 停止服务
- chat_enhanced_stop();
-
- // 终止响应线程
- if (g_chat_enhanced_context->response_thread != NULL) {
- osThreadTerminate(g_chat_enhanced_context->response_thread);
- }
-
- // 清理历史记录
- chat_enhanced_clear_history(g_chat_enhanced_context);
-
- // 清理资源
- if (g_chat_enhanced_context->timeout_timer != NULL) {
- osTimerDelete(g_chat_enhanced_context->timeout_timer);
- }
-
- if (g_chat_enhanced_context->response_sem != NULL) {
- osSemaphoreDelete(g_chat_enhanced_context->response_sem);
- }
-
- if (g_chat_enhanced_context->state_mutex != NULL) {
- osMutexDelete(g_chat_enhanced_context->state_mutex);
- }
-
- // 销毁基础Chat服务
- chat_server_destroy(&g_chat_enhanced_context->base);
-
- // 释放上下文
- free(g_chat_enhanced_context);
- g_chat_enhanced_context = NULL;
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Enhanced Chat service destroyed", CHAT_LOG_TAG);
- return AI_SERVICE_OK;
-}
-
-/**
- * @brief 启动Chat服务
- */
-ai_service_error_t chat_enhanced_start(void)
-{
- if (g_chat_enhanced_context == NULL) {
- return AI_SERVICE_ERROR_NOT_CONNECTED;
- }
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Starting Chat service", CHAT_LOG_TAG);
-
- // 启动基础Chat服务
- ai_service_error_t ret = chat_server_start(&g_chat_enhanced_context->base);
- if (ret != AI_SERVICE_OK) {
- return ret;
- }
-
- chat_enhanced_set_state(g_chat_enhanced_context, CHAT_STATE_IDLE);
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Chat service started", CHAT_LOG_TAG);
- return AI_SERVICE_OK;
-}
-
-/**
- * @brief 停止Chat服务
- */
-ai_service_error_t chat_enhanced_stop(void)
-{
- if (g_chat_enhanced_context == NULL) {
- return AI_SERVICE_OK;
- }
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Stopping Chat service", CHAT_LOG_TAG);
-
- osMutexAcquire(g_chat_enhanced_context->state_mutex, osWaitForever);
-
- // 如果正在接收响应，请求打断
- if (g_chat_enhanced_context->state == CHAT_STATE_RECEIVING) {
- g_chat_enhanced_context->interrupt_requested = true;
- chat_enhanced_set_state(g_chat_enhanced_context, CHAT_STATE_INTERRUPTED);
- }
-
- // 停止超时定时器
- osTimerStop(g_chat_enhanced_context->timeout_timer);
-
- osMutexRelease(g_chat_enhanced_context->state_mutex);
-
- // 停止基础Chat服务（这会断开WebSocket连接）
- chat_server_stop(&g_chat_enhanced_context->base);
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Chat service stopped", CHAT_LOG_TAG);
- return AI_SERVICE_OK;
-}
-
-/**
- * @brief 创建新会话
- */
-ai_service_error_t chat_enhanced_create_session(const char *session_id)
-{
- if (g_chat_enhanced_context == NULL || session_id == NULL) {
- return AI_SERVICE_ERROR_INVALID_PARAM;
- }
-
- osMutexAcquire(g_chat_enhanced_context->state_mutex, osWaitForever);
-
- // 清理旧的历史记录
- chat_enhanced_clear_history(g_chat_enhanced_context);
-
- // 设置新的会话ID
- strncpy(g_chat_enhanced_context->current_session_id, session_id,
- sizeof(g_chat_enhanced_context->current_session_id) - 1);
- g_chat_enhanced_context->current_session_id[sizeof(g_chat_enhanced_context->current_session_id) - 1] = '\0';
-
- osMutexRelease(g_chat_enhanced_context->state_mutex);
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Session created: %s", CHAT_LOG_TAG, session_id);
- return AI_SERVICE_OK;
-}
-
-/**
- * @brief 发送消息
- */
-ai_service_error_t chat_enhanced_send_message(const char *content, bool wait_response)
-{
- if (g_chat_enhanced_context == NULL || content == NULL) {
- return AI_SERVICE_ERROR_INVALID_PARAM;
- }
-
- osMutexAcquire(g_chat_enhanced_context->state_mutex, osWaitForever);
-
- if (g_chat_enhanced_context->state != CHAT_STATE_IDLE) {
- osMutexRelease(g_chat_enhanced_context->state_mutex);
- WEARABLE_LOGW(WEARABLE_LOG_MODULE_APP, "[%s] Chat not idle, current state: %d",
- CHAT_LOG_TAG, g_chat_enhanced_context->state);
- return AI_SERVICE_ERROR_NOT_CONNECTED;
- }
-
- // 创建用户消息
- chat_message_t message = {
- .role = CHAT_ROLE_USER,
- .content = (char*)content,
- .timestamp = osKernelGetTickCount()
- };
-
- // 添加到历史记录
- chat_enhanced_add_to_history(g_chat_enhanced_context, &message);
-
- // 发送消息
- ai_service_error_t ret = chat_enhanced_send_message_internal(g_chat_enhanced_context, &message);
- if (ret != AI_SERVICE_OK) {
- osMutexRelease(g_chat_enhanced_context->state_mutex);
- return ret;
- }
-
- chat_enhanced_set_state(g_chat_enhanced_context, CHAT_STATE_SENDING);
- g_chat_enhanced_context->last_message_time = osKernelGetTickCount();
- g_chat_enhanced_context->interrupt_requested = false;
- g_chat_enhanced_context->response_complete = false;
- g_chat_enhanced_context->response_length = 0;
-
- osMutexRelease(g_chat_enhanced_context->state_mutex);
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Message sent: %s", CHAT_LOG_TAG, content);
-
- // 如果需要等待响应
- if (wait_response) {
- osStatus_t status = osSemaphoreAcquire(g_chat_enhanced_context->response_sem,
- CHAT_INTERRUPT_TIMEOUT_MS);
- if (status != osOK) {
- WEARABLE_LOGW(WEARABLE_LOG_MODULE_APP, "[%s] Response timeout", CHAT_LOG_TAG);
- return AI_SERVICE_ERROR_TIMEOUT;
- }
- }
-
- return AI_SERVICE_OK;
-}
-
-/**
- * @brief 请求打断当前对话
- */
-ai_service_error_t chat_enhanced_interrupt_conversation(void)
-{
- if (g_chat_enhanced_context == NULL) {
- return AI_SERVICE_ERROR_NOT_CONNECTED;
- }
-
- osMutexAcquire(g_chat_enhanced_context->state_mutex, osWaitForever);
-
- if (g_chat_enhanced_context->state == CHAT_STATE_RECEIVING) {
- g_chat_enhanced_context->interrupt_requested = true;
- chat_enhanced_set_state(g_chat_enhanced_context, CHAT_STATE_INTERRUPTED);
-
- // 断开WebSocket连接来实现打断
- ai_service_disconnect(&g_chat_enhanced_context->base.base);
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Conversation interrupted", CHAT_LOG_TAG);
- }
-
- osMutexRelease(g_chat_enhanced_context->state_mutex);
- return AI_SERVICE_OK;
-}
-
-/**
- * @brief 设置连续对话模式
- */
-ai_service_error_t chat_enhanced_set_continuous_mode(bool enabled)
-{
- if (g_chat_enhanced_context == NULL) {
- return AI_SERVICE_ERROR_NOT_CONNECTED;
- }
-
- osMutexAcquire(g_chat_enhanced_context->state_mutex, osWaitForever);
- g_chat_enhanced_context->continuous_mode = enabled;
- osMutexRelease(g_chat_enhanced_context->state_mutex);
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Continuous mode %s",
- CHAT_LOG_TAG, enabled ? "enabled" : "disabled");
- return AI_SERVICE_OK;
-}
-
-/**
- * @brief 获取对话历史
- */
-const chat_message_t* chat_enhanced_get_history(uint32_t *count)
-{
- if (g_chat_enhanced_context == NULL || count == NULL) {
- return NULL;
- }
-
- osMutexAcquire(g_chat_enhanced_context->state_mutex, osWaitForever);
- *count = g_chat_enhanced_context->history_count;
-
- // 这里简化处理，实际应用中可能需要返回数组
- chat_history_node_t *node = g_chat_enhanced_context->history_head;
- osMutexRelease(g_chat_enhanced_context->state_mutex);
-
- return node ? &node->message : NULL;
-}
-
-/**
- * @brief 清除对话历史
- */
-ai_service_error_t chat_enhanced_clear_session_history(void)
-{
- if (g_chat_enhanced_context == NULL) {
- return AI_SERVICE_ERROR_NOT_CONNECTED;
- }
-
- osMutexAcquire(g_chat_enhanced_context->state_mutex, osWaitForever);
- chat_enhanced_clear_history(g_chat_enhanced_context);
- osMutexRelease(g_chat_enhanced_context->state_mutex);
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Session history cleared", CHAT_LOG_TAG);
- return AI_SERVICE_OK;
-}
-
-/**
- * @brief 设置回调函数
- */
-void chat_enhanced_set_callbacks(void (*on_response_start)(void *user_data, const char *session_id),
- void (*on_response_partial)(void *user_data, const char *session_id, const char *content),
- void (*on_response_end)(void *user_data, const char *session_id, const char *full_content),
- void (*on_error)(void *user_data, int error_code, const char *error_msg),
- void *user_data)
-{
- if (g_chat_enhanced_context == NULL) {
- return;
- }
-
- osMutexAcquire(g_chat_enhanced_context->state_mutex, osWaitForever);
- g_chat_enhanced_context->on_response_start = on_response_start;
- g_chat_enhanced_context->on_response_partial = on_response_partial;
- g_chat_enhanced_context->on_response_end = on_response_end;
- g_chat_enhanced_context->on_error = on_error;
- g_chat_enhanced_context->user_data = user_data;
- osMutexRelease(g_chat_enhanced_context->state_mutex);
-}
-
-/* ==================== 内部函数实现 ==================== */
-
-/**
- * @brief 响应处理线程
- */
-static void chat_enhanced_response_thread(void *arg)
-{
- chat_enhanced_context_t *context = (chat_enhanced_context_t *)arg;
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Response thread started", CHAT_LOG_TAG);
-
- while (true) {
- // 等待响应信号
- osSemaphoreAcquire(context->response_sem, osWaitForever);
-
- osMutexAcquire(context->state_mutex, osWaitForever);
-
- if (context->response_complete && !context->interrupt_requested) {
- // 创建助手消息并添加到历史
- chat_message_t assistant_message = {
- .role = CHAT_ROLE_ASSISTANT,
- .content = context->response_buffer,
- .timestamp = osKernelGetTickCount()
- };
-
- chat_enhanced_add_to_history(context, &assistant_message);
-
- // 调用完成回调
- if (context->on_response_end != NULL) {
- context->on_response_end(context->user_data,
- context->current_session_id,
- context->response_buffer);
- }
-
- chat_enhanced_set_state(context, CHAT_STATE_IDLE);
- }
-
- osMutexRelease(context->state_mutex);
- }
-}
-
-/**
- * @brief 超时回调
- */
-static void chat_enhanced_timeout_callback(void *arg)
-{
- chat_enhanced_context_t *context = (chat_enhanced_context_t *)arg;
-
- WEARABLE_LOGW(WEARABLE_LOG_MODULE_APP, "[%s] Response timeout", CHAT_LOG_TAG);
-
- osMutexAcquire(context->state_mutex, osWaitForever);
-
- if (context->state == CHAT_STATE_RECEIVING) {
- context->interrupt_requested = true;
- chat_enhanced_set_state(context, CHAT_STATE_INTERRUPTED);
-
- // 调用错误回调
- if (context->on_error != NULL) {
- context->on_error(context->user_data, AI_SERVICE_ERROR_TIMEOUT, "Response timeout");
- }
- }
-
- osMutexRelease(context->state_mutex);
-}
-
-/**
- * @brief 发送消息内部实现
- */
-static ai_service_error_t chat_enhanced_send_message_internal(chat_enhanced_context_t *context,
- const chat_message_t *message)
-{
- // 构建包含历史记录的完整消息
- cJSON *root = cJSON_CreateObject();
- cJSON *messages = cJSON_CreateArray();
-
- if (root == NULL || messages == NULL) {
- if (root) cJSON_Delete(root);
- if (messages) cJSON_Delete(messages);
- return AI_SERVICE_ERROR_MEMORY_ALLOC;
- }
-
- // 添加历史消息
- chat_history_node_t *node = context->history_head;
- while (node != NULL) {
- cJSON *msg_obj = cJSON_CreateObject();
- if (msg_obj != NULL) {
- cJSON_AddStringToObject(msg_obj, "role",
- node->message.role == CHAT_ROLE_USER ? "user" : "assistant");
- cJSON_AddStringToObject(msg_obj, "content", node->message.content);
- cJSON_AddItemToArray(messages, msg_obj);
- }
- node = node->next;
- }
-
- // 设置消息数组
- cJSON_AddItemToObject(root, "messages", messages);
-
- // 添加模型配置
- cJSON_AddStringToObject(root, "model", context->base.model_config.model_name);
- cJSON_AddNumberToObject(root, "temperature", context->base.model_config.temperature);
- cJSON_AddNumberToObject(root, "max_tokens", context->base.model_config.max_tokens);
- cJSON_AddBoolToObject(root, "stream", true);
-
- char *json_string = cJSON_Print(root);
- cJSON_Delete(root);
-
- if (json_string == NULL) {
- return AI_SERVICE_ERROR_MEMORY_ALLOC;
- }
-
- // 发送消息
- ai_service_error_t ret = ai_service_send_data(&context->base.base, json_string, strlen(json_string));
- free(json_string);
-
- return ret;
-}
-
-/**
- * @brief 解析响应
- */
-static ai_service_error_t chat_enhanced_parse_response(chat_enhanced_context_t *context,
- const char *json_data)
-{
- cJSON *root = cJSON_Parse(json_data);
- if (root == NULL) {
- return AI_SERVICE_ERROR_INVALID_PARAM;
- }
-
- cJSON *type_obj = cJSON_GetObjectItem(root, "type");
- if (type_obj == NULL || !cJSON_IsString(type_obj)) {
- cJSON_Delete(root);
- return AI_SERVICE_ERROR_INVALID_PARAM;
- }
-
- const char *type = cJSON_GetStringValue(type_obj);
- cJSON *content_obj = cJSON_GetObjectItem(root, "content");
- const char *content = cJSON_IsString(content_obj) ? cJSON_GetStringValue(content_obj) : NULL;
-
- if (strcmp(type, "start") == 0) {
- // 响应开始
- chat_enhanced_set_state(context, CHAT_STATE_RECEIVING);
- context->response_length = 0;
- context->response_buffer[0] = '\0';
-
- // 启动超时定时器
- osTimerStart(context->timeout_timer, CHAT_INTERRUPT_TIMEOUT_MS);
-
- // 调用开始回调
- if (context->on_response_start != NULL) {
- context->on_response_start(context->user_data, context->current_session_id);
- }
-
- } else if (strcmp(type, "middle") == 0 && content != NULL) {
- // 响应中间部分
- if (context->state == CHAT_STATE_RECEIVING && !context->interrupt_requested) {
- // 追加内容到缓冲区
- size_t content_len = strlen(content);
- if (context->response_length + content_len < CHAT_MAX_RESPONSE_BUFFER - 1) {
- strcat(context->response_buffer, content);
- context->response_length += content_len;
-
- // 调用部分回调
- if (context->on_response_partial != NULL) {
- context->on_response_partial(context->user_data,
- context->current_session_id,
- content);
- }
- }
- }
-
- } else if (strcmp(type, "end") == 0) {
- // 响应结束
- osTimerStop(context->timeout_timer);
- context->response_complete = true;
-
- // 通知响应线程
- osSemaphoreRelease(context->response_sem);
- }
-
- cJSON_Delete(root);
- return AI_SERVICE_OK;
-}
-
-/**
- * @brief 添加消息到历史记录
- */
-static void chat_enhanced_add_to_history(chat_enhanced_context_t *context,
- const chat_message_t *message)
-{
- if (context->history_count >= CHAT_MAX_HISTORY_SIZE) {
- // 删除最旧的消息
- chat_history_node_t *old_tail = context->history_head;
- if (old_tail != NULL) {
- while (old_tail->next && old_tail->next->next) {
- old_tail = old_tail->next;
- }
- if (old_tail->next) {
- free(old_tail->next->message.content);
- free(old_tail->next);
- old_tail->next = NULL;
- context->history_count--;
- }
- }
- }
-
- // 创建新节点
- chat_history_node_t *new_node = (chat_history_node_t *)malloc(sizeof(chat_history_node_t));
- if (new_node == NULL) {
- return;
- }
-
- // 复制消息内容
- new_node->message = *message;
- new_node->message.content = (char *)malloc(strlen(message->content) + 1);
- if (new_node->message.content == NULL) {
- free(new_node);
- return;
- }
- strcpy(new_node->message.content, message->content);
-
- // 插入到头部
- new_node->next = context->history_head;
- context->history_head = new_node;
- context->history_count++;
-}
-
-/**
- * @brief 清除历史记录
- */
-static void chat_enhanced_clear_history(chat_enhanced_context_t *context)
-{
- chat_history_node_t *node = context->history_head;
- while (node != NULL) {
- chat_history_node_t *next = node->next;
- free(node->message.content);
- free(node);
- node = next;
- }
-
- context->history_head = NULL;
- context->history_count = 0;
-}
-
-/**
- * @brief 设置对话状态
- */
-static void chat_enhanced_set_state(chat_enhanced_context_t *context,
- chat_conversation_state_t new_state)
-{
- chat_conversation_state_t old_state = context->state;
- context->state = new_state;
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] State changed: %d -> %d",
- CHAT_LOG_TAG, old_state, new_state);
-}
-
-/* ==================== WebSocket回调函数 ==================== */
-
-static void chat_enhanced_on_websocket_connected(void *context)
-{
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] WebSocket connected", CHAT_LOG_TAG);
-}
-
-static void chat_enhanced_on_websocket_disconnected(void *context)
-{
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] WebSocket disconnected", CHAT_LOG_TAG);
-
- if (g_chat_enhanced_context != NULL) {
- osMutexAcquire(g_chat_enhanced_context->state_mutex, osWaitForever);
-
- // 如果是因为打断而断开，重新连接
- if (g_chat_enhanced_context->state == CHAT_STATE_INTERRUPTED) {
- chat_enhanced_set_state(g_chat_enhanced_context, CHAT_STATE_IDLE);
-
- // 如果启用了连续模式，自动重连
- if (g_chat_enhanced_context->continuous_mode) {
- ai_service_connect(&g_chat_enhanced_context->base.base);
- }
- }
-
- osMutexRelease(g_chat_enhanced_context->state_mutex);
- }
-}
-
-static void chat_enhanced_on_websocket_message(void *context, const char *data, size_t length)
-{
- if (g_chat_enhanced_context == NULL || data == NULL || length == 0) {
- return;
- }
-
- // 解析响应消息
- chat_enhanced_parse_response(g_chat_enhanced_context, data);
-}
-
-static void chat_enhanced_on_websocket_error(void *context, int error_code, const char *error_msg)
-{
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] WebSocket error: %d - %s",
- CHAT_LOG_TAG, error_code, error_msg ? error_msg : "Unknown");
-
- if (g_chat_enhanced_context != NULL) {
- osMutexAcquire(g_chat_enhanced_context->state_mutex, osWaitForever);
-
- chat_enhanced_set_state(g_chat_enhanced_context, CHAT_STATE_IDLE);
-
- // 调用错误回调
- if (g_chat_enhanced_context->on_error != NULL) {
- g_chat_enhanced_context->on_error(g_chat_enhanced_context->user_data,
- error_code, error_msg);
- }
-
- osMutexRelease(g_chat_enhanced_context->state_mutex);
- }
-}
-
-#ifdef __cplusplus
-}
-#endif
\ No newline at end of file
+++ /dev/null
-/*
- * Copyright (c) CompanyNameMagicTag. 2023-2023. All rights reserved.
- * Description: Enhanced TTS Server Implementation - 双向流式合成
- * Author: AI Development Team
- * Create: 2024-12-28
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "tts_server.h"
-#include "ai_media.h"
-#include "../../../../application/wearable/ohos_deps/wearable_log.h"
-#include "../../../../../open_source/openharmony/third_party/cJSON/cJSON.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* ==================== 函数声明 ==================== */
-static ai_service_error_t tts_enhanced_stop(void);
-
-/* ==================== 内部宏定义 ==================== */
-
-#define TTS_LOG_TAG "TTS_ENHANCED"
-#define TTS_MAX_TEXT_CHUNK_SIZE 512
-#define TTS_TRACE_ID_LENGTH 32
-#define TTS_PLAYBACK_BUFFER_SIZE 8192
-
-/* ==================== 内部结构体定义 ==================== */
-
-/**
- * @brief TTS流式合成状态
- */
-typedef enum {
- TTS_STREAM_STATE_IDLE = 0,
- TTS_STREAM_STATE_STARTING,
- TTS_STREAM_STATE_RUNNING,
- TTS_STREAM_STATE_STOPPING,
- TTS_STREAM_STATE_STOPPED
-} tts_stream_state_t;
-
-/**
- * @brief TTS文本块结构
- */
-typedef struct {
- char *text;
- size_t length;
- bool is_final;
-} tts_text_chunk_t;
-
-/**
- * @brief 增强的TTS上下文
- */
-typedef struct {
- tts_server_context_t base; // 基础TTS上下文
-
- /* 流式合成相关 */
- tts_stream_state_t stream_state;
- char trace_id[TTS_TRACE_ID_LENGTH];
- osMessageQueueId_t text_queue; // 文本队列
- osThreadId_t synthesis_thread; // 合成线程
-
- /* 播放服务管理 */
- bool playback_service_active; // 播放服务状态
- bool playback_control_enabled; // 播放控制开关
- osMessageQueueId_t audio_queue; // 音频数据队列
- osThreadId_t playback_thread; // 播放线程
-
- /* 同步控制 */
- osMutexId_t stream_mutex;
- osSemaphoreId_t synthesis_sem;
-
- /* 统计信息 */
- uint32_t total_text_chunks;
- uint32_t total_audio_chunks;
- uint32_t synthesis_start_time;
-} tts_enhanced_context_t;
-
-/* ==================== 全局变量 ==================== */
-
-static tts_enhanced_context_t *g_tts_enhanced_context = NULL;
-
-/* ==================== 内部函数声明 ==================== */
-
-static void tts_enhanced_synthesis_thread(void *arg);
-static void tts_enhanced_playback_thread(void *arg);
-static ai_service_error_t tts_enhanced_send_start_synthesis(tts_enhanced_context_t *context);
-static ai_service_error_t tts_enhanced_send_run_synthesis(tts_enhanced_context_t *context, const char *text);
-static ai_service_error_t tts_enhanced_send_stop_synthesis(tts_enhanced_context_t *context);
-static ai_service_error_t tts_enhanced_parse_synthesis_event(tts_enhanced_context_t *context,
- const char *json_data);
-static void tts_enhanced_generate_trace_id(char *trace_id, size_t max_len);
-static void tts_enhanced_on_websocket_message(void *context, const char *data, size_t length);
-static void tts_enhanced_on_websocket_connected(void *context);
-static void tts_enhanced_on_websocket_disconnected(void *context);
-static void tts_enhanced_on_websocket_error(void *context, int error_code, const char *error_msg);
-
-/* ==================== 公共接口实现 ==================== */
-
-/**
- * @brief 初始化增强TTS服务
- */
-ai_service_error_t tts_enhanced_init(const ai_service_config_t *config,
- const tts_audio_config_t *audio_config,
- const tts_voice_config_t *voice_config)
-{
- if (config == NULL || audio_config == NULL || voice_config == NULL) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Invalid parameters", TTS_LOG_TAG);
- return AI_SERVICE_ERROR_INVALID_PARAM;
- }
-
- if (g_tts_enhanced_context != NULL) {
- WEARABLE_LOGW(WEARABLE_LOG_MODULE_APP, "[%s] Already initialized", TTS_LOG_TAG);
- return AI_SERVICE_ERROR_ALREADY_CONNECTED;
- }
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Initializing enhanced TTS service", TTS_LOG_TAG);
-
- // 分配上下文内存
- g_tts_enhanced_context = (tts_enhanced_context_t *)malloc(sizeof(tts_enhanced_context_t));
- if (g_tts_enhanced_context == NULL) {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] Failed to allocate context", TTS_LOG_TAG);
- return AI_SERVICE_ERROR_MEMORY_ALLOC;
- }
-
- memset(g_tts_enhanced_context, 0, sizeof(tts_enhanced_context_t));
-
- // 初始化基础TTS服务
- ai_service_error_t ret = tts_server_init(&g_tts_enhanced_context->base,
- config->server_url,
- audio_config,
- voice_config);
- if (ret != AI_SERVICE_OK) {
- free(g_tts_enhanced_context);
- g_tts_enhanced_context = NULL;
- return ret;
- }
-
- // 复制配置
- memcpy(&g_tts_enhanced_context->base.audio_config, audio_config, sizeof(tts_audio_config_t));
- memcpy(&g_tts_enhanced_context->base.voice_config, voice_config, sizeof(tts_voice_config_t));
-
- // 初始化流式合成状态
- g_tts_enhanced_context->stream_state = TTS_STREAM_STATE_IDLE;
- tts_enhanced_generate_trace_id(g_tts_enhanced_context->trace_id,
- sizeof(g_tts_enhanced_context->trace_id));
-
- // 创建互斥锁和信号量
- g_tts_enhanced_context->stream_mutex = osMutexNew(NULL);
- if (g_tts_enhanced_context->stream_mutex == NULL) {
- tts_server_destroy(&g_tts_enhanced_context->base);
- free(g_tts_enhanced_context);
- g_tts_enhanced_context = NULL;
- return AI_SERVICE_ERROR_INTERNAL;
- }
-
- g_tts_enhanced_context->synthesis_sem = osSemaphoreNew(1, 0, NULL);
- if (g_tts_enhanced_context->synthesis_sem == NULL) {
- osMutexDelete(g_tts_enhanced_context->stream_mutex);
- tts_server_destroy(&g_tts_enhanced_context->base);
- free(g_tts_enhanced_context);
- g_tts_enhanced_context = NULL;
- return AI_SERVICE_ERROR_INTERNAL;
- }
-
- // 创建文本队列
- g_tts_enhanced_context->text_queue = osMessageQueueNew(32, sizeof(tts_text_chunk_t), NULL);
- if (g_tts_enhanced_context->text_queue == NULL) {
- osSemaphoreDelete(g_tts_enhanced_context->synthesis_sem);
- osMutexDelete(g_tts_enhanced_context->stream_mutex);
- tts_server_destroy(&g_tts_enhanced_context->base);
- free(g_tts_enhanced_context);
- g_tts_enhanced_context = NULL;
- return AI_SERVICE_ERROR_INTERNAL;
- }
-
- // 创建音频队列
- g_tts_enhanced_context->audio_queue = osMessageQueueNew(16, TTS_PLAYBACK_BUFFER_SIZE, NULL);
- if (g_tts_enhanced_context->audio_queue == NULL) {
- osMessageQueueDelete(g_tts_enhanced_context->text_queue);
- osSemaphoreDelete(g_tts_enhanced_context->synthesis_sem);
- osMutexDelete(g_tts_enhanced_context->stream_mutex);
- tts_server_destroy(&g_tts_enhanced_context->base);
- free(g_tts_enhanced_context);
- g_tts_enhanced_context = NULL;
- return AI_SERVICE_ERROR_INTERNAL;
- }
-
- // 创建合成线程
- osThreadAttr_t synthesis_attr = {
- .name = "tts_synthesis",
- .stack_size = 8192,
- .priority = osPriorityNormal
- };
-
- g_tts_enhanced_context->synthesis_thread = osThreadNew(tts_enhanced_synthesis_thread,
- g_tts_enhanced_context,
- &synthesis_attr);
- if (g_tts_enhanced_context->synthesis_thread == NULL) {
- osMessageQueueDelete(g_tts_enhanced_context->audio_queue);
- osMessageQueueDelete(g_tts_enhanced_context->text_queue);
- osSemaphoreDelete(g_tts_enhanced_context->synthesis_sem);
- osMutexDelete(g_tts_enhanced_context->stream_mutex);
- tts_server_destroy(&g_tts_enhanced_context->base);
- free(g_tts_enhanced_context);
- g_tts_enhanced_context = NULL;
- return AI_SERVICE_ERROR_INTERNAL;
- }
-
- // 创建播放线程
- osThreadAttr_t playback_attr = {
- .name = "tts_playback",
- .stack_size = 4096,
- .priority = osPriorityHigh
- };
-
- g_tts_enhanced_context->playback_thread = osThreadNew(tts_enhanced_playback_thread,
- g_tts_enhanced_context,
- &playback_attr);
- if (g_tts_enhanced_context->playback_thread == NULL) {
- osThreadTerminate(g_tts_enhanced_context->synthesis_thread);
- osMessageQueueDelete(g_tts_enhanced_context->audio_queue);
- osMessageQueueDelete(g_tts_enhanced_context->text_queue);
- osSemaphoreDelete(g_tts_enhanced_context->synthesis_sem);
- osMutexDelete(g_tts_enhanced_context->stream_mutex);
- tts_server_destroy(&g_tts_enhanced_context->base);
- free(g_tts_enhanced_context);
- g_tts_enhanced_context = NULL;
- return AI_SERVICE_ERROR_INTERNAL;
- }
-
- // 设置WebSocket回调
- ai_service_set_callbacks(&g_tts_enhanced_context->base.base,
- tts_enhanced_on_websocket_connected,
- tts_enhanced_on_websocket_disconnected,
- tts_enhanced_on_websocket_message,
- tts_enhanced_on_websocket_error);
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Enhanced TTS service initialized", TTS_LOG_TAG);
- return AI_SERVICE_OK;
-}
-
-/**
- * @brief 销毁增强TTS服务
- */
-ai_service_error_t tts_enhanced_destroy(void)
-{
- if (g_tts_enhanced_context == NULL) {
- return AI_SERVICE_OK;
- }
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Destroying enhanced TTS service", TTS_LOG_TAG);
-
- // 停止服务
- tts_enhanced_stop();
-
- // 终止线程
- if (g_tts_enhanced_context->synthesis_thread != NULL) {
- osThreadTerminate(g_tts_enhanced_context->synthesis_thread);
- }
-
- if (g_tts_enhanced_context->playback_thread != NULL) {
- osThreadTerminate(g_tts_enhanced_context->playback_thread);
- }
-
- // 清理资源
- if (g_tts_enhanced_context->audio_queue != NULL) {
- osMessageQueueDelete(g_tts_enhanced_context->audio_queue);
- }
-
- if (g_tts_enhanced_context->text_queue != NULL) {
- osMessageQueueDelete(g_tts_enhanced_context->text_queue);
- }
-
- if (g_tts_enhanced_context->synthesis_sem != NULL) {
- osSemaphoreDelete(g_tts_enhanced_context->synthesis_sem);
- }
-
- if (g_tts_enhanced_context->stream_mutex != NULL) {
- osMutexDelete(g_tts_enhanced_context->stream_mutex);
- }
-
- // 销毁基础TTS服务
- tts_server_destroy(&g_tts_enhanced_context->base);
-
- // 释放上下文
- free(g_tts_enhanced_context);
- g_tts_enhanced_context = NULL;
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Enhanced TTS service destroyed", TTS_LOG_TAG);
- return AI_SERVICE_OK;
-}
-
-/**
- * @brief 启动TTS服务
- */
-ai_service_error_t tts_enhanced_start(void)
-{
- if (g_tts_enhanced_context == NULL) {
- return AI_SERVICE_ERROR_NOT_CONNECTED;
- }
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Starting TTS service", TTS_LOG_TAG);
-
- // 启动基础TTS服务
- ai_service_error_t ret = tts_server_start(&g_tts_enhanced_context->base);
- if (ret != AI_SERVICE_OK) {
- return ret;
- }
-
- // 启动播放服务
- ai_media_play_start((uint8_t*)"pcm");
- if (1) { // ai_media_play_start returns void, assume success
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Media playback started", TTS_LOG_TAG);
- } else {
- g_tts_enhanced_context->playback_service_active = true;
- }
-
- g_tts_enhanced_context->playback_control_enabled = true;
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] TTS service started", TTS_LOG_TAG);
- return AI_SERVICE_OK;
-}
-
-/**
- * @brief 停止TTS服务
- */
-ai_service_error_t tts_enhanced_stop(void)
-{
- if (g_tts_enhanced_context == NULL) {
- return AI_SERVICE_OK;
- }
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Stopping TTS service", TTS_LOG_TAG);
-
- osMutexAcquire(g_tts_enhanced_context->stream_mutex, osWaitForever);
-
- // 停止流式合成
- if (g_tts_enhanced_context->stream_state == TTS_STREAM_STATE_RUNNING) {
- tts_enhanced_send_stop_synthesis(g_tts_enhanced_context);
- g_tts_enhanced_context->stream_state = TTS_STREAM_STATE_STOPPING;
- }
-
- // 禁用播放控制
- g_tts_enhanced_context->playback_control_enabled = false;
-
- // 停止播放服务
- if (g_tts_enhanced_context->playback_service_active) {
- ai_media_play_stop();
- g_tts_enhanced_context->playback_service_active = false;
- }
-
- osMutexRelease(g_tts_enhanced_context->stream_mutex);
-
- // 停止基础TTS服务
- tts_server_stop(&g_tts_enhanced_context->base);
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] TTS service stopped", TTS_LOG_TAG);
- return AI_SERVICE_OK;
-}
-
-/**
- * @brief 开始流式合成
- */
-ai_service_error_t tts_enhanced_start_synthesis(const char *session_id)
-{
- if (g_tts_enhanced_context == NULL) {
- return AI_SERVICE_ERROR_NOT_CONNECTED;
- }
-
- osMutexAcquire(g_tts_enhanced_context->stream_mutex, osWaitForever);
-
- if (g_tts_enhanced_context->stream_state != TTS_STREAM_STATE_IDLE) {
- osMutexRelease(g_tts_enhanced_context->stream_mutex);
- WEARABLE_LOGW(WEARABLE_LOG_MODULE_APP, "[%s] Synthesis already active", TTS_LOG_TAG);
- return AI_SERVICE_ERROR_ALREADY_CONNECTED;
- }
-
- // 生成新的trace_id
- tts_enhanced_generate_trace_id(g_tts_enhanced_context->trace_id,
- sizeof(g_tts_enhanced_context->trace_id));
-
- // 发送StartSynthesis消息
- ai_service_error_t ret = tts_enhanced_send_start_synthesis(g_tts_enhanced_context);
- if (ret != AI_SERVICE_OK) {
- osMutexRelease(g_tts_enhanced_context->stream_mutex);
- return ret;
- }
-
- g_tts_enhanced_context->stream_state = TTS_STREAM_STATE_STARTING;
- g_tts_enhanced_context->synthesis_start_time = osKernelGetTickCount();
- g_tts_enhanced_context->total_text_chunks = 0;
- g_tts_enhanced_context->total_audio_chunks = 0;
-
- osMutexRelease(g_tts_enhanced_context->stream_mutex);
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Synthesis started: %s", TTS_LOG_TAG, session_id);
- return AI_SERVICE_OK;
-}
-
-/**
- * @brief 发送文本进行合成
- */
-ai_service_error_t tts_enhanced_send_text(const char *text, bool is_final)
-{
- if (g_tts_enhanced_context == NULL || text == NULL) {
- return AI_SERVICE_ERROR_INVALID_PARAM;
- }
-
- osMutexAcquire(g_tts_enhanced_context->stream_mutex, osWaitForever);
-
- if (g_tts_enhanced_context->stream_state != TTS_STREAM_STATE_RUNNING &&
- g_tts_enhanced_context->stream_state != TTS_STREAM_STATE_STARTING) {
- osMutexRelease(g_tts_enhanced_context->stream_mutex);
- WEARABLE_LOGW(WEARABLE_LOG_MODULE_APP, "[%s] Synthesis not active", TTS_LOG_TAG);
- return AI_SERVICE_ERROR_NOT_CONNECTED;
- }
-
- // 创建文本块
- tts_text_chunk_t chunk = {
- .text = (char *)malloc(strlen(text) + 1),
- .length = strlen(text),
- .is_final = is_final
- };
-
- if (chunk.text == NULL) {
- osMutexRelease(g_tts_enhanced_context->stream_mutex);
- return AI_SERVICE_ERROR_MEMORY_ALLOC;
- }
-
- strcpy(chunk.text, text);
-
- // 发送到文本队列
- osStatus_t status = osMessageQueuePut(g_tts_enhanced_context->text_queue, &chunk, 0, 0);
- if (status != osOK) {
- free(chunk.text);
- osMutexRelease(g_tts_enhanced_context->stream_mutex);
- WEARABLE_LOGW(WEARABLE_LOG_MODULE_APP, "[%s] Text queue full", TTS_LOG_TAG);
- return AI_SERVICE_ERROR_INTERNAL;
- }
-
- g_tts_enhanced_context->total_text_chunks++;
- osMutexRelease(g_tts_enhanced_context->stream_mutex);
-
- // 通知合成线程
- osSemaphoreRelease(g_tts_enhanced_context->synthesis_sem);
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Text sent: %s (final: %d)", TTS_LOG_TAG, text, is_final);
- return AI_SERVICE_OK;
-}
-
-/**
- * @brief 停止流式合成
- */
-ai_service_error_t tts_enhanced_stop_synthesis(void)
-{
- if (g_tts_enhanced_context == NULL) {
- return AI_SERVICE_ERROR_NOT_CONNECTED;
- }
-
- osMutexAcquire(g_tts_enhanced_context->stream_mutex, osWaitForever);
-
- if (g_tts_enhanced_context->stream_state == TTS_STREAM_STATE_IDLE ||
- g_tts_enhanced_context->stream_state == TTS_STREAM_STATE_STOPPED) {
- osMutexRelease(g_tts_enhanced_context->stream_mutex);
- return AI_SERVICE_OK;
- }
-
- // 发送StopSynthesis消息
- tts_enhanced_send_stop_synthesis(g_tts_enhanced_context);
- g_tts_enhanced_context->stream_state = TTS_STREAM_STATE_STOPPING;
-
- osMutexRelease(g_tts_enhanced_context->stream_mutex);
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Synthesis stopped", TTS_LOG_TAG);
- return AI_SERVICE_OK;
-}
-
-/**
- * @brief 启用/禁用播放控制
- */
-ai_service_error_t tts_enhanced_set_playback_control(bool enabled)
-{
- if (g_tts_enhanced_context == NULL) {
- return AI_SERVICE_ERROR_NOT_CONNECTED;
- }
-
- osMutexAcquire(g_tts_enhanced_context->stream_mutex, osWaitForever);
- g_tts_enhanced_context->playback_control_enabled = enabled;
- osMutexRelease(g_tts_enhanced_context->stream_mutex);
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Playback control %s",
- TTS_LOG_TAG, enabled ? "enabled" : "disabled");
- return AI_SERVICE_OK;
-}
-
-/* ==================== 内部函数实现 ==================== */
-
-/**
- * @brief 合成线程
- */
-static void tts_enhanced_synthesis_thread(void *arg)
-{
- tts_enhanced_context_t *context = (tts_enhanced_context_t *)arg;
- tts_text_chunk_t chunk;
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Synthesis thread started", TTS_LOG_TAG);
-
- while (true) {
- // 等待文本数据
- osSemaphoreAcquire(context->synthesis_sem, osWaitForever);
-
- // 从队列获取文本块
- osStatus_t status = osMessageQueueGet(context->text_queue, &chunk, NULL, 0);
- if (status == osOK) {
- // 发送RunSynthesis消息
- tts_enhanced_send_run_synthesis(context, chunk.text);
-
- // 如果是最后一块，发送停止消息
- if (chunk.is_final) {
- osDelay(100); // 等待一下再发送停止消息
- tts_enhanced_send_stop_synthesis(context);
- }
-
- // 释放文本内存
- free(chunk.text);
- }
- }
-}
-
-/**
- * @brief 播放线程
- */
-static void tts_enhanced_playback_thread(void *arg)
-{
- tts_enhanced_context_t *context = (tts_enhanced_context_t *)arg;
- uint8_t audio_buffer[TTS_PLAYBACK_BUFFER_SIZE];
-
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Playback thread started", TTS_LOG_TAG);
-
- while (true) {
- // 从音频队列获取数据
- osStatus_t status = osMessageQueueGet(context->audio_queue, audio_buffer, NULL, 1000);
- if (status == osOK) {
- // 检查播放控制
- osMutexAcquire(context->stream_mutex, osWaitForever);
- bool can_play = context->playback_control_enabled && context->playback_service_active;
- osMutexRelease(context->stream_mutex);
-
- if (can_play) {
- // 播放音频数据
- ai_media_play_buffer(audio_buffer, TTS_PLAYBACK_BUFFER_SIZE);
- }
- }
- }
-}
-
-/**
- * @brief 发送StartSynthesis消息
- */
-static ai_service_error_t tts_enhanced_send_start_synthesis(tts_enhanced_context_t *context)
-{
- cJSON *root = cJSON_CreateObject();
- cJSON *header = cJSON_CreateObject();
- cJSON *payload = cJSON_CreateObject();
-
- if (root == NULL || header == NULL || payload == NULL) {
- if (root) cJSON_Delete(root);
- if (header) cJSON_Delete(header);
- if (payload) cJSON_Delete(payload);
- return AI_SERVICE_ERROR_MEMORY_ALLOC;
- }
-
- // 构建header
- cJSON_AddStringToObject(header, "event", "StartSynthesis");
- cJSON_AddStringToObject(header, "trace_id", context->trace_id);
-
- // 构建payload
- cJSON_AddStringToObject(payload, "voice",
- tts_server_voice_type_to_string(context->base.voice_config.voice_type));
- cJSON_AddStringToObject(payload, "format", "WAV");
- cJSON_AddNumberToObject(payload, "sample_rate", context->base.audio_config.sample_rate);
- cJSON_AddNumberToObject(payload, "volume", context->base.voice_config.volume);
- cJSON_AddNumberToObject(payload, "speech_rate", context->base.voice_config.speed);
-
- // 组装消息
- cJSON_AddItemToObject(root, "header", header);
- cJSON_AddItemToObject(root, "payload", payload);
-
- char *json_string = cJSON_Print(root);
- cJSON_Delete(root);
-
- if (json_string == NULL) {
- return AI_SERVICE_ERROR_MEMORY_ALLOC;
- }
-
- // 发送消息
- ai_service_error_t ret = ai_service_send_data(&context->base.base, json_string, strlen(json_string));
- free(json_string);
-
- return ret;
-}
-
-/**
- * @brief 发送RunSynthesis消息
- */
-static ai_service_error_t tts_enhanced_send_run_synthesis(tts_enhanced_context_t *context, const char *text)
-{
- cJSON *root = cJSON_CreateObject();
- cJSON *header = cJSON_CreateObject();
- cJSON *payload = cJSON_CreateObject();
-
- if (root == NULL || header == NULL || payload == NULL) {
- if (root) cJSON_Delete(root);
- if (header) cJSON_Delete(header);
- if (payload) cJSON_Delete(payload);
- return AI_SERVICE_ERROR_MEMORY_ALLOC;
- }
-
- // 构建header
- cJSON_AddStringToObject(header, "event", "RunSynthesis");
- cJSON_AddStringToObject(header, "trace_id", context->trace_id);
-
- // 构建payload
- cJSON_AddStringToObject(payload, "text", text);
-
- // 组装消息
- cJSON_AddItemToObject(root, "header", header);
- cJSON_AddItemToObject(root, "payload", payload);
-
- char *json_string = cJSON_Print(root);
- cJSON_Delete(root);
-
- if (json_string == NULL) {
- return AI_SERVICE_ERROR_MEMORY_ALLOC;
- }
-
- // 发送消息
- ai_service_error_t ret = ai_service_send_data(&context->base.base, json_string, strlen(json_string));
- free(json_string);
-
- return ret;
-}
-
-/**
- * @brief 发送StopSynthesis消息
- */
-static ai_service_error_t tts_enhanced_send_stop_synthesis(tts_enhanced_context_t *context)
-{
- cJSON *root = cJSON_CreateObject();
- cJSON *header = cJSON_CreateObject();
-
- if (root == NULL || header == NULL) {
- if (root) cJSON_Delete(root);
- if (header) cJSON_Delete(header);
- return AI_SERVICE_ERROR_MEMORY_ALLOC;
- }
-
- // 构建header
- cJSON_AddStringToObject(header, "event", "StopSynthesis");
- cJSON_AddStringToObject(header, "trace_id", context->trace_id);
-
- // 组装消息
- cJSON_AddItemToObject(root, "header", header);
-
- char *json_string = cJSON_Print(root);
- cJSON_Delete(root);
-
- if (json_string == NULL) {
- return AI_SERVICE_ERROR_MEMORY_ALLOC;
- }
-
- // 发送消息
- ai_service_error_t ret = ai_service_send_data(&context->base.base, json_string, strlen(json_string));
- free(json_string);
-
- return ret;
-}
-
-/**
- * @brief 解析合成事件
- */
-static ai_service_error_t tts_enhanced_parse_synthesis_event(tts_enhanced_context_t *context,
- const char *json_data)
-{
- cJSON *root = cJSON_Parse(json_data);
- if (root == NULL) {
- return AI_SERVICE_ERROR_INVALID_PARAM;
- }
-
- cJSON *header = cJSON_GetObjectItem(root, "header");
- if (header == NULL) {
- cJSON_Delete(root);
- return AI_SERVICE_ERROR_INVALID_PARAM;
- }
-
- cJSON *event = cJSON_GetObjectItem(header, "event");
- if (event == NULL || !cJSON_IsString(event)) {
- cJSON_Delete(root);
- return AI_SERVICE_ERROR_INVALID_PARAM;
- }
-
- const char *event_str = cJSON_GetStringValue(event);
-
- if (strcmp(event_str, "SentenceBegin") == 0) {
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Sentence begin", TTS_LOG_TAG);
-
- } else if (strcmp(event_str, "SentenceSynthesis") == 0) {
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Sentence synthesis", TTS_LOG_TAG);
- context->total_audio_chunks++;
-
- } else if (strcmp(event_str, "SentenceEnd") == 0) {
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Sentence end", TTS_LOG_TAG);
-
- } else if (strcmp(event_str, "EndSynthesis") == 0) {
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] Synthesis completed", TTS_LOG_TAG);
-
- osMutexAcquire(context->stream_mutex, osWaitForever);
- context->stream_state = TTS_STREAM_STATE_IDLE;
- osMutexRelease(context->stream_mutex);
- }
-
- cJSON_Delete(root);
- return AI_SERVICE_OK;
-}
-
-/**
- * @brief 生成trace_id
- */
-static void tts_enhanced_generate_trace_id(char *trace_id, size_t max_len)
-{
- if (trace_id == NULL || max_len == 0) {
- return;
- }
-
- uint32_t timestamp = osKernelGetTickCount();
- static uint32_t counter = 0;
-
- snprintf(trace_id, max_len, "%08x%08x%08x%08x",
- timestamp, ++counter, rand(), rand());
-}
-
-/* ==================== WebSocket回调函数 ==================== */
-
-static void tts_enhanced_on_websocket_connected(void *context)
-{
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] WebSocket connected", TTS_LOG_TAG);
-}
-
-static void tts_enhanced_on_websocket_disconnected(void *context)
-{
- WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[%s] WebSocket disconnected", TTS_LOG_TAG);
-
- if (g_tts_enhanced_context != NULL) {
- osMutexAcquire(g_tts_enhanced_context->stream_mutex, osWaitForever);
- g_tts_enhanced_context->stream_state = TTS_STREAM_STATE_IDLE;
- osMutexRelease(g_tts_enhanced_context->stream_mutex);
- }
-}
-
-static void tts_enhanced_on_websocket_message(void *context, const char *data, size_t length)
-{
- if (g_tts_enhanced_context == NULL || data == NULL || length == 0) {
- return;
- }
-
- // 检查是否为JSON数据
- if (data[0] == '{') {
- // JSON消息，解析事件
- tts_enhanced_parse_synthesis_event(g_tts_enhanced_context, data);
- } else {
- // 二进制音频数据
- osMutexAcquire(g_tts_enhanced_context->stream_mutex, osWaitForever);
- bool can_queue = g_tts_enhanced_context->playback_control_enabled;
- osMutexRelease(g_tts_enhanced_context->stream_mutex);
-
- if (can_queue && length <= TTS_PLAYBACK_BUFFER_SIZE) {
- // 发送到音频队列
- osMessageQueuePut(g_tts_enhanced_context->audio_queue, data, 0, 0);
- }
- }
-}
-
-static void tts_enhanced_on_websocket_error(void *context, int error_code, const char *error_msg)
-{
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[%s] WebSocket error: %d - %s",
- TTS_LOG_TAG, error_code, error_msg ? error_msg : "Unknown");
-
- if (g_tts_enhanced_context != NULL) {
- osMutexAcquire(g_tts_enhanced_context->stream_mutex, osWaitForever);
- g_tts_enhanced_context->stream_state = TTS_STREAM_STATE_IDLE;
- osMutexRelease(g_tts_enhanced_context->stream_mutex);
- }
-}
-
-#ifdef __cplusplus
-}
-#endif
\ No newline at end of file
projects / mirrors / FD230.git / commitdiff