From: 孙春阳 Date: Tue, 2 Sep 2025 06:56:36 +0000 (+0800) Subject: 更新ai service代码,添加at测试指令 X-Git-Tag: leiniao_debug_1.0.0_20250922_020716~113^2~11 X-Git-Url: http://git.snicker.com.cn/css/static/gitweb.css?a=commitdiff_plain;h=1c7c9902ac3186643a39c266f8133e07430df1b6;p=mirrors%2FFD230.git 更新ai service代码,添加at测试指令 --- diff --git a/code/sdk/application/brandy/brandy_standard/service_init.c b/code/sdk/application/brandy/brandy_standard/service_init.c index d00288e18..5b7a12560 100644 --- a/code/sdk/application/brandy/brandy_standard/service_init.c +++ b/code/sdk/application/brandy/brandy_standard/service_init.c @@ -99,6 +99,10 @@ #ifdef SUPPORT_AT_LEINIAO_API #include "leiniao_api_at.h" #endif +#ifdef SUPPORT_ZHIHUI_AI_SERVICE +#include "ai_at_cmd.h" +#endif + static void register_at_service(void) { #ifdef SUPPORT_AT_GRAPHIC @@ -230,6 +234,13 @@ static void register_at_service(void) at_cmd_table_t *leiniao_api_table = get_leiniao_api_cmd_table(&leiniao_api_cmd_count); at_cmd_add_moudle(leiniao_api_table, leiniao_api_cmd_count); #endif + +#ifdef SUPPORT_ZHIHUI_AI_SERVICE + uint32_t ai_cmd_count; + at_cmd_table_t *ai_table = get_ai_cmd_table(&ai_cmd_count); + at_cmd_add_moudle(ai_table, ai_cmd_count); +#endif + } #ifdef CONFIG_OTA_UPDATE_SUPPORT diff --git a/code/sdk/zhihui/ai/CMakeLists.txt b/code/sdk/zhihui/ai/CMakeLists.txt index c8d974e72..0d9202537 100644 --- a/code/sdk/zhihui/ai/CMakeLists.txt +++ b/code/sdk/zhihui/ai/CMakeLists.txt @@ -16,12 +16,13 @@ ${ROOT_DIR}/open_source/openharmony/third_party/cJSON ${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 @@ -31,6 +32,7 @@ set(SOURCES set(COMPONENT_PUBLIC_CCFLAGS ) +# LiteOS-M优化的编译选项 set(COMPONENT_CCFLAGS -std=c99 -Wall @@ -39,9 +41,16 @@ set(COMPONENT_CCFLAGS -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 @@ -52,11 +61,12 @@ set(MAIN_COMPONENT 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 diff --git a/code/sdk/zhihui/ai/Makefile b/code/sdk/zhihui/ai/Makefile new file mode 100644 index 000000000..67ed0308b --- /dev/null +++ b/code/sdk/zhihui/ai/Makefile @@ -0,0 +1,139 @@ +# 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 diff --git "a/code/sdk/zhihui/ai/doc/\351\270\277\350\222\231AI\346\234\215\345\212\241-\346\236\266\346\236\204\350\256\276\350\256\241\345\233\276-\344\274\230\345\214\226\347\211\210v2.md" "b/code/sdk/zhihui/ai/doc/\351\270\277\350\222\231AI\346\234\215\345\212\241-\346\236\266\346\236\204\350\256\276\350\256\241\345\233\276-\344\274\230\345\214\226\347\211\210v2.md" new file mode 100644 index 000000000..0c134eb1f --- /dev/null +++ "b/code/sdk/zhihui/ai/doc/\351\270\277\350\222\231AI\346\234\215\345\212\241-\346\236\266\346\236\204\350\256\276\350\256\241\345\233\276-\344\274\230\345\214\226\347\211\210v2.md" @@ -0,0 +1,343 @@ +# 鸿蒙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 diff --git a/code/sdk/zhihui/ai/example/AI_AT_TEST_README.md b/code/sdk/zhihui/ai/example/AI_AT_TEST_README.md deleted file mode 100644 index 584e8ddd4..000000000 --- a/code/sdk/zhihui/ai/example/AI_AT_TEST_README.md +++ /dev/null @@ -1,375 +0,0 @@ -# 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-文本)
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 diff --git a/code/sdk/zhihui/ai/example/CMakeLists.txt b/code/sdk/zhihui/ai/example/CMakeLists.txt deleted file mode 100644 index c6dd88185..000000000 --- a/code/sdk/zhihui/ai/example/CMakeLists.txt +++ /dev/null @@ -1,56 +0,0 @@ -#=============================================================================== -# @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 diff --git a/code/sdk/zhihui/ai/example/ai_at_cmd.c b/code/sdk/zhihui/ai/example/ai_at_cmd.c new file mode 100644 index 000000000..79af5b5ca --- /dev/null +++ b/code/sdk/zhihui/ai/example/ai_at_cmd.c @@ -0,0 +1,857 @@ +/** + * @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 +#include +#include +#include +#include +#include +#ifdef __TEST_MODE__ +#include +#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 diff --git a/code/sdk/zhihui/ai/example/ai_at_test.c b/code/sdk/zhihui/ai/example/ai_at_test.c deleted file mode 100644 index 09a415945..000000000 --- a/code/sdk/zhihui/ai/example/ai_at_test.c +++ /dev/null @@ -1,595 +0,0 @@ -/* - * 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 -#include -#include -#include -#include - -#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 diff --git a/code/sdk/zhihui/ai/example/ai_at_test.h b/code/sdk/zhihui/ai/example/ai_at_test.h deleted file mode 100644 index 876efdc85..000000000 --- a/code/sdk/zhihui/ai/example/ai_at_test.h +++ /dev/null @@ -1,87 +0,0 @@ -/* - * 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 -#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 diff --git a/code/sdk/zhihui/ai/example/ai_at_test_example.c b/code/sdk/zhihui/ai/example/ai_at_test_example.c deleted file mode 100644 index b9a887e1c..000000000 --- a/code/sdk/zhihui/ai/example/ai_at_test_example.c +++ /dev/null @@ -1,276 +0,0 @@ -/* - * 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 -#include - -#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 diff --git a/code/sdk/zhihui/ai/example/ai_demo.c b/code/sdk/zhihui/ai/example/ai_demo.c new file mode 100644 index 000000000..1abac93a8 --- /dev/null +++ b/code/sdk/zhihui/ai/example/ai_demo.c @@ -0,0 +1,750 @@ +/** + * @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 +#include +#include +#include + +#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 diff --git a/code/sdk/zhihui/ai/example/ai_service_usage_example.c b/code/sdk/zhihui/ai/example/ai_service_usage_example.c deleted file mode 100644 index f2a7d6448..000000000 --- a/code/sdk/zhihui/ai/example/ai_service_usage_example.c +++ /dev/null @@ -1,450 +0,0 @@ -/* - * Copyright (c) CompanyNameMagicTag. 2023-2023. All rights reserved. - * Description: AI Service Usage Example - AI全家桶使用示例 - * Author: AI Development Team - * Create: 2024-12-28 - */ - -#include -#include -#include -#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 diff --git a/code/sdk/zhihui/ai/example/ai_services_example.c b/code/sdk/zhihui/ai/example/ai_services_example.c deleted file mode 100644 index 0d5cd8ae6..000000000 --- a/code/sdk/zhihui/ai/example/ai_services_example.c +++ /dev/null @@ -1,484 +0,0 @@ -/* - * AI服务集成示例代码 - * 演示ASR、TTS、Chat三个服务的协同工作 - */ - -#include -#include -#include -#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 diff --git a/code/sdk/zhihui/ai/include/ai_at_cmd.h b/code/sdk/zhihui/ai/include/ai_at_cmd.h new file mode 100644 index 000000000..715e3d465 --- /dev/null +++ b/code/sdk/zhihui/ai/include/ai_at_cmd.h @@ -0,0 +1,49 @@ +/** + * @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 +#include + +#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 diff --git a/code/sdk/zhihui/ai/include/ai_at_commands.h b/code/sdk/zhihui/ai/include/ai_at_commands.h new file mode 100644 index 000000000..caefe5e2c --- /dev/null +++ b/code/sdk/zhihui/ai/include/ai_at_commands.h @@ -0,0 +1,233 @@ +/** + * @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 diff --git a/code/sdk/zhihui/ai/include/ai_connection_manager.h b/code/sdk/zhihui/ai/include/ai_connection_manager.h new file mode 100644 index 000000000..cd5112cb1 --- /dev/null +++ b/code/sdk/zhihui/ai/include/ai_connection_manager.h @@ -0,0 +1,244 @@ +/** + * @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 diff --git a/code/sdk/zhihui/ai/include/ai_core_types.h b/code/sdk/zhihui/ai/include/ai_core_types.h new file mode 100644 index 000000000..c3273bc10 --- /dev/null +++ b/code/sdk/zhihui/ai/include/ai_core_types.h @@ -0,0 +1,269 @@ +/** + * @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 +#include +#include + +/* 系统依赖头文件 - 条件编译 */ +#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 diff --git a/code/sdk/zhihui/ai/include/ai_memory_pool.h b/code/sdk/zhihui/ai/include/ai_memory_pool.h new file mode 100644 index 000000000..2154c9dcf --- /dev/null +++ b/code/sdk/zhihui/ai/include/ai_memory_pool.h @@ -0,0 +1,286 @@ +/** + * @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 diff --git a/code/sdk/zhihui/ai/include/ai_service_common.h b/code/sdk/zhihui/ai/include/ai_service_common.h deleted file mode 100644 index ce6eb4ea2..000000000 --- a/code/sdk/zhihui/ai/include/ai_service_common.h +++ /dev/null @@ -1,271 +0,0 @@ -/* - * AI服务通用头文件 - * 定义ASR、TTS、Chat服务的通用数据结构和接口 - */ - -#ifndef AI_SERVICE_COMMON_H -#define AI_SERVICE_COMMON_H - -#include -#include -#include -#include -#include -#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 diff --git a/code/sdk/zhihui/ai/include/ai_service_manager.h b/code/sdk/zhihui/ai/include/ai_service_manager.h deleted file mode 100644 index dbc9966eb..000000000 --- a/code/sdk/zhihui/ai/include/ai_service_manager.h +++ /dev/null @@ -1,323 +0,0 @@ -/* - * 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 -#include -#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 diff --git a/code/sdk/zhihui/ai/include/ai_services.h b/code/sdk/zhihui/ai/include/ai_services.h new file mode 100644 index 000000000..ec865dcea --- /dev/null +++ b/code/sdk/zhihui/ai/include/ai_services.h @@ -0,0 +1,384 @@ +/** + * @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 diff --git a/code/sdk/zhihui/ai/include/asr_server.h b/code/sdk/zhihui/ai/include/asr_server.h deleted file mode 100644 index 150509a56..000000000 --- a/code/sdk/zhihui/ai/include/asr_server.h +++ /dev/null @@ -1,303 +0,0 @@ -/* - * 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 diff --git a/code/sdk/zhihui/ai/include/chat_server.h b/code/sdk/zhihui/ai/include/chat_server.h deleted file mode 100644 index 9672a79ce..000000000 --- a/code/sdk/zhihui/ai/include/chat_server.h +++ /dev/null @@ -1,393 +0,0 @@ -/* - * 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 diff --git a/code/sdk/zhihui/ai/include/tts_server.h b/code/sdk/zhihui/ai/include/tts_server.h deleted file mode 100644 index d8b6dbded..000000000 --- a/code/sdk/zhihui/ai/include/tts_server.h +++ /dev/null @@ -1,375 +0,0 @@ -/* - * 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 diff --git a/code/sdk/zhihui/ai/src/ai_connection_manager.c b/code/sdk/zhihui/ai/src/ai_connection_manager.c new file mode 100644 index 000000000..827895e42 --- /dev/null +++ b/code/sdk/zhihui/ai/src/ai_connection_manager.c @@ -0,0 +1,1049 @@ +/** + * @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 +#include + +#ifdef __TEST_MODE__ +#include // 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 diff --git a/code/sdk/zhihui/ai/src/ai_memory_pool.c b/code/sdk/zhihui/ai/src/ai_memory_pool.c new file mode 100644 index 000000000..bc2842cf2 --- /dev/null +++ b/code/sdk/zhihui/ai/src/ai_memory_pool.c @@ -0,0 +1,976 @@ +/** + * @file ai_memory_pool.c + * @brief AI智能内存池管理器实现 - LiteOS-M优化版v2 + * @version 2.0 + * @date 2024-01-20 + */ + +#include "ai_memory_pool.h" +#include +#include +#include + +#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 diff --git a/code/sdk/zhihui/ai/src/ai_service_common.c b/code/sdk/zhihui/ai/src/ai_service_common.c deleted file mode 100644 index c8f9c6904..000000000 --- a/code/sdk/zhihui/ai/src/ai_service_common.c +++ /dev/null @@ -1,902 +0,0 @@ -/* - * AI服务通用功能实现 - * 提供ASR、TTS、Chat服务的通用基础功能 - */ - -#include -#include -#include -#include -#include -#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 diff --git a/code/sdk/zhihui/ai/src/ai_service_manager.c b/code/sdk/zhihui/ai/src/ai_service_manager.c deleted file mode 100644 index f5cb1c54f..000000000 --- a/code/sdk/zhihui/ai/src/ai_service_manager.c +++ /dev/null @@ -1,1064 +0,0 @@ -/* - * 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 -#include -#include -#include - -#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 diff --git a/code/sdk/zhihui/ai/src/ai_services.c b/code/sdk/zhihui/ai/src/ai_services.c new file mode 100644 index 000000000..918894dfe --- /dev/null +++ b/code/sdk/zhihui/ai/src/ai_services.c @@ -0,0 +1,867 @@ +/** + * @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 +#include +#include +#include + +#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 diff --git a/code/sdk/zhihui/ai/src/asr_server_enhanced.c b/code/sdk/zhihui/ai/src/asr_server_enhanced.c deleted file mode 100644 index c263c108f..000000000 --- a/code/sdk/zhihui/ai/src/asr_server_enhanced.c +++ /dev/null @@ -1,757 +0,0 @@ -/* - * Copyright (c) CompanyNameMagicTag. 2023-2023. All rights reserved. - * Description: Enhanced ASR Server Implementation - 语音识别服务增强版 - * Author: AI Development Team - * Create: 2024-12-28 - */ - -#include -#include -#include -#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 diff --git a/code/sdk/zhihui/ai/src/chat_server_enhanced.c b/code/sdk/zhihui/ai/src/chat_server_enhanced.c deleted file mode 100644 index 40b9fb48f..000000000 --- a/code/sdk/zhihui/ai/src/chat_server_enhanced.c +++ /dev/null @@ -1,820 +0,0 @@ -/* - * Copyright (c) CompanyNameMagicTag. 2023-2023. All rights reserved. - * Description: Enhanced Chat Server Implementation - 对话服务增强版 - * Author: AI Development Team - * Create: 2024-12-28 - */ - -#include -#include -#include -#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 diff --git a/code/sdk/zhihui/ai/src/tts_server_enhanced.c b/code/sdk/zhihui/ai/src/tts_server_enhanced.c deleted file mode 100644 index 96e3a45bc..000000000 --- a/code/sdk/zhihui/ai/src/tts_server_enhanced.c +++ /dev/null @@ -1,799 +0,0 @@ -/* - * Copyright (c) CompanyNameMagicTag. 2023-2023. All rights reserved. - * Description: Enhanced TTS Server Implementation - 双向流式合成 - * Author: AI Development Team - * Create: 2024-12-28 - */ - -#include -#include -#include -#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