From 392bd54638632bee3aa9111befebef79f8e6d150 Mon Sep 17 00:00:00 2001 From: =?utf8?q?=E5=AD=99=E6=98=A5=E9=98=B3?= Date: Sat, 8 Nov 2025 07:35:39 +0800 Subject: [PATCH] =?utf8?q?lwip=20=E4=BC=98=E5=8C=96TCP=5FWND=20=E4=B8=8B?= =?utf8?q?=E8=BD=BD=E5=88=B7=E6=96=B0=E8=BF=9B=E5=BA=A6=E6=9D=A1=E4=BC=98?= =?utf8?q?=E5=8C=96=20sio=E7=BB=9F=E8=AE=A1=20=E6=89=93=E5=8D=B0=E4=BF=A1?= =?utf8?q?=E6=81=AF=E4=BC=98=E5=8C=96=20sse=E8=B6=85=E6=97=B6=E4=BC=98?= =?utf8?q?=E5=8C=96=20http=EF=BC=8Chttpdownload=20=E7=BB=9F=E4=B8=80?= =?utf8?q?=E6=8E=A5=E5=8F=A3=EF=BC=8C=E7=BB=9F=E4=B8=80=E8=B0=83=E9=85=8D?= =?utf8?q?=E5=8A=9F=E8=80=97=E6=96=B9=E4=BE=BF?= MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit --- .../config/target_config/brandy/config.py | 2 + .../chips/brandy/pm/include/pm_definition.h | 1 + code/sdk/middleware/chips/brandy/pm/pm.c | 23 +- .../lwip/lwip_adapter/liteos/src/arch/sio.c | 198 +++- .../src/include/lwip/lwipopts_default.h | 84 +- .../src/apps/altcp_tls/altcp_tls_mbedtls.c | 13 + .../lwip/lwip_v2.1.3/src/netif/slipif.c | 464 +++++++++- code/sdk/zhihui/4g/cat1Service/CMakeLists.txt | 2 +- .../4g/cat1Service/Service/cat1_utils.c | 16 +- .../4g/cat1Service/include/cat1_porting.h | 12 + code/sdk/zhihui/4gTest/cat1_porting.c | 30 +- .../sdk/zhihui/leiniao/imsl_ln/CMakeLists.txt | 3 + .../leiniao/imsl_ln/HTTP_CLIENT_USAGE.md | 867 ++++++++++++++++++ code/sdk/zhihui/leiniao/imsl_ln/ln_api.c | 270 +++++- code/sdk/zhihui/leiniao/imsl_ln/ln_api.h | 5 + .../leiniao/imsl_ln/ln_api_device_info.c | 404 ++++---- .../sdk/zhihui/leiniao/imsl_ln/ln_api_emoji.c | 505 +++++----- code/sdk/zhihui/leiniao/imsl_ln/ln_api_ota.c | 268 ++++-- .../leiniao/imsl_ln/ln_api_speech_chat.c | 247 ++--- .../leiniao/imsl_ln/ln_api_story_choose.c | 250 ++--- .../leiniao/imsl_ln/ln_api_story_exit.c | 123 +-- .../leiniao/imsl_ln/ln_api_story_finish.c | 117 +-- .../leiniao/imsl_ln/ln_api_story_random.c | 244 ++--- .../imsl_ln/ln_api_timeline_activities.c | 103 +-- .../sdk/zhihui/leiniao/imsl_ln/ln_api_token.c | 181 ++-- .../leiniao/imsl_ln/ln_file_write_queue.c | 544 +++++++++++ .../leiniao/imsl_ln/ln_file_write_queue.h | 119 +++ .../zhihui/leiniao/imsl_ln/ln_http_client.c | 247 +++++ .../zhihui/leiniao/imsl_ln/ln_http_client.h | 128 +++ .../leiniao/imsl_ln/ln_http_download_client.c | 278 ++++++ .../leiniao/imsl_ln/ln_http_download_client.h | 99 ++ code/sdk/zhihui/ppp/src/ppp_cat1_api.c | 22 +- .../services/gnss/src/gnss_http_server.c | 6 + code/sdk/zhihui/utils/custom_utils.c | 2 +- 34 files changed, 4634 insertions(+), 1243 deletions(-) create mode 100644 code/sdk/zhihui/leiniao/imsl_ln/HTTP_CLIENT_USAGE.md create mode 100644 code/sdk/zhihui/leiniao/imsl_ln/ln_file_write_queue.c create mode 100644 code/sdk/zhihui/leiniao/imsl_ln/ln_file_write_queue.h create mode 100644 code/sdk/zhihui/leiniao/imsl_ln/ln_http_client.c create mode 100644 code/sdk/zhihui/leiniao/imsl_ln/ln_http_client.h create mode 100644 code/sdk/zhihui/leiniao/imsl_ln/ln_http_download_client.c create mode 100644 code/sdk/zhihui/leiniao/imsl_ln/ln_http_download_client.h diff --git a/code/sdk/build/config/target_config/brandy/config.py b/code/sdk/build/config/target_config/brandy/config.py index 495c4a22d..867f83b2f 100644 --- a/code/sdk/build/config/target_config/brandy/config.py +++ b/code/sdk/build/config/target_config/brandy/config.py @@ -1253,6 +1253,7 @@ target = { 'FT_SINGLE_UART', 'SUPPORT_CAT1_SERVICE', 'SUPPORT_CAT1_UART_WAKEUP', + 'SUPPORT_SLIP_SERVICE_INTERRUPT', 'CONFIG_EFUSE_READ_TO_RAM', 'CUSTOM_UTILS', @@ -1477,6 +1478,7 @@ target = { # 'SUPPORT_PPP_SERVICE_POLLING', # 'CONFIG_UART_SUPPORT_DMA', # ppp interrupt 读取串口 与polling只能开启一个 + 'SUPPORT_PPP_SERVICE', 'SUPPORT_PPP_SERVICE_INTERRUPT', 'SUPPORT_CAT1_UART_WAKEUP', #离线日志 diff --git a/code/sdk/middleware/chips/brandy/pm/include/pm_definition.h b/code/sdk/middleware/chips/brandy/pm/include/pm_definition.h index dc8745eb7..9c217aa51 100644 --- a/code/sdk/middleware/chips/brandy/pm/include/pm_definition.h +++ b/code/sdk/middleware/chips/brandy/pm/include/pm_definition.h @@ -48,6 +48,7 @@ typedef enum { PM_ID_MOTOR,//新增,马达 PM_ID_GSENSOR,//新增,加速计 PM_ID_CAT1,//Cat1 communication + PM_ID_CAT1_APP,//Cat1 communication PM_ID_P_TEST,//产测 PM_ID_BUTTON_GPIO,//gpio按键 PM_ID_BP,//血压 diff --git a/code/sdk/middleware/chips/brandy/pm/pm.c b/code/sdk/middleware/chips/brandy/pm/pm.c index 1ab7b5d17..0e04767a6 100644 --- a/code/sdk/middleware/chips/brandy/pm/pm.c +++ b/code/sdk/middleware/chips/brandy/pm/pm.c @@ -238,20 +238,23 @@ const char* pm_id_name_arr[] ={ "PM_ID_STORAGE", "PM_ID_TOUCH", "PM_ID_JPEG", - "PM_ID_JS", - "PM_ID_MSGCENTER", + "PM_ID_JS", + "PM_ID_MSGCENTER", "PM_ID_SPI_DMA", "PM_ID_I2C_DMA", "PM_ID_UART_DMA", - "PM_ID_HEART",//����������оƬ - "PM_ID_MOTOR",//���������� - "PM_ID_GSENSOR",//���������ټ� - "PM_ID_CAT1",//Cat1 communication - "PM_ID_P_TEST", - "PM_ID_BUTTON_GPIO",//GPIO���� - "PM_ID_4G_AI",//AI投票 + "PM_ID_HEART", //新增,心率芯片 + "PM_ID_MOTOR", //新增,马达 + "PM_ID_GSENSOR", //新增,加速计 + "PM_ID_CAT1", //Cat1 communication + "PM_ID_CAT1_APP", //Cat1 communication + "PM_ID_P_TEST", //产测 + "PM_ID_BUTTON_GPIO", //gpio按键 + "PM_ID_BP", //血压 + "PM_ID_4G_AI", //4g AI + "PM_ID_GPS", //4g AI #ifdef SUPPORT_ALIPAY_SEC - "PM_ID_ALIPAY",//支付宝 + "PM_ID_ALIPAY", //支付宝 #endif "PM_ID_MAX" }; diff --git a/code/sdk/open_source/openharmony/third_party/lwip/lwip_adapter/liteos/src/arch/sio.c b/code/sdk/open_source/openharmony/third_party/lwip/lwip_adapter/liteos/src/arch/sio.c index b94f2a28b..ca84b213d 100644 --- a/code/sdk/open_source/openharmony/third_party/lwip/lwip_adapter/liteos/src/arch/sio.c +++ b/code/sdk/open_source/openharmony/third_party/lwip/lwip_adapter/liteos/src/arch/sio.c @@ -49,6 +49,9 @@ #include #include "pmu_interrupt.h" +//是否使用单独的queue和thread处理slip数据 +#define USE_SIO_PROCESS_THREAD + /* 乒乓缓冲区配置 */ #ifndef SIO_PING_PONG_BUFFER_SIZE #define SIO_PING_PONG_BUFFER_SIZE 2048 // 每个buffer大小(2KB) @@ -63,7 +66,7 @@ #define SIO_IRQ_PROCESS_STACK_SIZE 4096 // 处理线程栈大小 /* CAT1 vote 管理配置(与PPP保持一致) */ -#ifdef SUPPORT_PPP_SERVICE_INTERRUPT +#ifdef SUPPORT_SLIP_SERVICE_INTERRUPT #define SIO_CAT1_VOTE_IDLE_MS 3000 // 3秒空闲后移除CAT1 vote #endif @@ -101,6 +104,9 @@ typedef struct { uint32_t buffer_switch_count; // buffer切换次数 uint32_t dropped_both_full; // 两个buffer都满导致丢弃的字节数 uint32_t cross_buffer_count; // 跨buffer写入次数 + uint32_t last_stat_time_ms; // 上次统计时间(用于计算速率) + uint32_t last_bytes_received; // 上次统计时的接收字节数(用于计算速率) + uint32_t last_bytes_processed; // 上次统计时的处理字节数(用于计算速率) } sio_stats_t; /* SIO UART buffer configuration */ @@ -158,14 +164,19 @@ static volatile uint32_t g_sio_timer_timestamp_ms = 0; /* 定时器相关 */ static osal_timer g_sio_timeout_timer; static volatile bool g_sio_timer_running = false; +/* 统计打印标志:由定时器设置,由处理线程打印(避免定时器回调栈溢出) */ +static volatile bool g_sio_stats_print_requested = false; /* 统计信息 */ static sio_stats_t g_sio_stats = {0}; +/* SLIP统计打印函数声明(在slipif.c中实现) */ +extern void slipif_print_stats(void); + /* 数据处理回调函数指针 - 用于将数据传递给SLIP */ static void (*g_sio_data_callback)(const uint8_t *data, uint32_t len) = NULL; -#ifdef SUPPORT_PPP_SERVICE_INTERRUPT +#ifdef SUPPORT_SLIP_SERVICE_INTERRUPT /* CAT1 vote 状态管理(与PPP保持一致) */ static volatile bool g_sio_cat1_vote_added = false; static volatile uint32_t g_sio_last_rx_time_ms = 0; // 最后接收数据时间 @@ -250,6 +261,12 @@ static void sio_irq_process_thread(void *arg) buffer->state = SIO_BUFFER_STATE_EMPTY; buffer->write_pos = 0; buffer->first_write_time = 0; + + // 检查是否需要打印统计信息(由定时器回调请求,避免在定时器回调中打印导致栈溢出) + if (g_sio_stats_print_requested) { + g_sio_stats_print_requested = false; + sio_print_stats(); + } } printf("[SIO] IRQ process thread exited\n"); @@ -305,16 +322,12 @@ static void sio_timeout_timer_callback(unsigned long arg) static volatile uint32_t timer_call_count = 0; timer_call_count++; - // 每100次(约3秒)打印一次诊断信息 - if ((timer_call_count % 100) == 1) { - printf("[SIO] Timer callback executed %u times, enabled=%d, running=%d\n", - timer_call_count, g_sio_interrupt_enabled, g_sio_timer_running); - } - - // 每333次(约10秒)打印一次完整统计信息 + // ⚠️ 定时器回调中避免使用printf,避免栈溢出 + // 每333次(约10秒)请求打印一次完整统计信息(包含诊断信息) // 30ms * 333 ≈ 10秒 + // 改为设置标志,由处理线程打印(处理线程有更大的栈空间) if ((timer_call_count % 333) == 0) { - sio_print_stats(); + g_sio_stats_print_requested = true; } if (!g_sio_interrupt_enabled || !g_sio_timer_running) { @@ -326,16 +339,34 @@ static void sio_timeout_timer_callback(unsigned long arg) // ⚠️ 更新全局时间戳(供ISR使用,ISR中不能调用时间函数) g_sio_timer_timestamp_ms = current_time; -#ifdef SUPPORT_PPP_SERVICE_INTERRUPT +#ifdef SUPPORT_SLIP_SERVICE_INTERRUPT // ✅ CAT1 vote 管理:检测 idle 状态,超过阈值时移除 vote if (g_sio_cat1_vote_added) { if (g_sio_last_rx_time_ms > 0) { uint32_t idle_time = current_time - g_sio_last_rx_time_ms; if (idle_time >= SIO_CAT1_VOTE_IDLE_MS) { // 空闲时间超过阈值,移除 vote 允许 CAT1 休眠 + printf("[SIO_CAT1_VOTE] Removing vote after %ums idle (last_rx=%u, current=%u)\n", + idle_time, g_sio_last_rx_time_ms, current_time); cat1_api_remove_cat1_vote(); g_sio_cat1_vote_added = false; - printf("[SIO_CAT1_VOTE] Removed vote after %ums idle\n", idle_time); + g_sio_last_rx_time_ms = 0; // 重置时间戳 + } + } else { + // 如果 last_rx_time_ms 为 0,说明可能没有数据接收,但 vote 仍然存在 + // 这种情况可能是初始化时添加的 vote,但从未收到数据 + // 为了避免永久占用 vote,在定时器回调中检查并清理 + static uint32_t vote_add_time = 0; + if (vote_add_time == 0) { + vote_add_time = current_time; + } else { + uint32_t elapsed = current_time - vote_add_time; + if (elapsed >= SIO_CAT1_VOTE_IDLE_MS) { + printf("[SIO_CAT1_VOTE] Removing vote: no data received for %ums\n", elapsed); + cat1_api_remove_cat1_vote(); + g_sio_cat1_vote_added = false; + vote_add_time = 0; + } } } } @@ -418,11 +449,15 @@ restart_timer: } /** - * @brief UART接收中断回调函数(乒乓缓冲区模式) + * @brief UART接收中断回调函数 + * + * 根据 USE_SIO_PROCESS_THREAD 宏定义选择处理方式: + * - 定义了 USE_SIO_PROCESS_THREAD:使用乒乓缓冲区 + queue + thread 模式 + * - 未定义:直接调用 callback 发送给 SLIP 处理 */ static void sio_uart_rx_interrupt_handler(const void *buffer, uint16_t length, bool error) { - if (!buffer || length == 0 || length > 200 || g_sio_ping_pong_buffers == NULL) { + if (!buffer || length == 0 || length > 200) { g_sio_stats.error_count++; return; } @@ -434,16 +469,24 @@ static void sio_uart_rx_interrupt_handler(const void *buffer, uint16_t length, b g_sio_stats.total_interrupts++; g_sio_stats.total_bytes_received += length; -#ifdef SUPPORT_PPP_SERVICE_INTERRUPT +#ifdef SUPPORT_SLIP_SERVICE_INTERRUPT // ✅ 更新最后接收时间(用于空闲检测) g_sio_last_rx_time_ms = g_sio_timer_timestamp_ms; // ✅ CAT1 vote 管理:接收数据时添加 vote(保持 CAT1 唤醒) if (!g_sio_cat1_vote_added) { + printf("[SIO_CAT1_VOTE] Adding vote on data reception (len=%u)\n", length); cat1_api_add_cat1_vote(); g_sio_cat1_vote_added = true; } #endif + +#ifdef USE_SIO_PROCESS_THREAD + /* 使用乒乓缓冲区 + queue + thread 模式 */ + if (g_sio_ping_pong_buffers == NULL) { + g_sio_stats.error_count++; + return; + } uint8_t current_idx = g_sio_current_buffer_index; sio_ping_pong_buffer_t *current_buffer = &g_sio_ping_pong_buffers[current_idx]; @@ -550,6 +593,13 @@ static void sio_uart_rx_interrupt_handler(const void *buffer, uint16_t length, b } else { g_sio_stats.dropped_both_full += length; } +#else + /* 直接调用 callback 发送给 SLIP 处理 */ + if (g_sio_data_callback != NULL) { + g_sio_data_callback((const uint8_t *)buffer, length); + g_sio_stats.total_bytes_processed += length; + } +#endif } /** @@ -587,7 +637,11 @@ static errcode_t sio_uart_init(void) } /** - * @brief 启用SIO中断模式(乒乓缓冲区) + * @brief 启用SIO中断模式 + * + * 根据 USE_SIO_PROCESS_THREAD 宏定义选择处理方式: + * - 定义了 USE_SIO_PROCESS_THREAD:使用乒乓缓冲区 + queue + thread 模式 + * - 未定义:直接调用 callback 模式(在中断中直接调用) */ errcode_t sio_interrupt_enable(void (*data_callback)(const uint8_t *data, uint32_t len)) { @@ -596,10 +650,15 @@ errcode_t sio_interrupt_enable(void (*data_callback)(const uint8_t *data, uint32 return ERRCODE_SUCC; } - printf("[SIO] Enabling interrupt mode (ping-pong buffer)\n"); - // 保存数据回调函数 g_sio_data_callback = data_callback; +#ifdef SUPPORT_SLIP_SERVICE_INTERRUPT + // 初始化 CAT1 vote 状态 + g_sio_cat1_vote_added = false; + g_sio_last_rx_time_ms = 0; +#endif +#ifdef USE_SIO_PROCESS_THREAD + printf("[SIO] Enabling interrupt mode (ping-pong buffer + queue + thread)\n"); // 1. 动态分配乒乓缓冲区内存 if (g_sio_ping_pong_buffers != NULL) { @@ -637,11 +696,7 @@ errcode_t sio_interrupt_enable(void (*data_callback)(const uint8_t *data, uint32 } g_sio_current_buffer_index = 0; -#ifdef SUPPORT_PPP_SERVICE_INTERRUPT - // 初始化 CAT1 vote 状态 - g_sio_cat1_vote_added = false; - g_sio_last_rx_time_ms = 0; -#endif + printf("[SIO] Allocated %d x %d bytes = %.2f KB total\n", SIO_PING_PONG_BUFFER_COUNT, SIO_PING_PONG_BUFFER_SIZE, @@ -735,19 +790,26 @@ errcode_t sio_interrupt_enable(void (*data_callback)(const uint8_t *data, uint32 } printf("[SIO] Timeout timer started (period=%d ms)\n", SIO_PING_PONG_TIMEOUT_MS); - - g_sio_interrupt_enabled = true; - - printf("[SIO] Interrupt mode enabled successfully!\n"); printf(" - Buffers: %d x %d KB\n", SIO_PING_PONG_BUFFER_COUNT, SIO_PING_PONG_BUFFER_SIZE / 1024); printf(" - Timeout: %d ms\n", SIO_PING_PONG_TIMEOUT_MS); printf(" - Queue: %d slots\n", SIO_IRQ_MSG_QUEUE_SIZE); +#else + printf("[SIO] Enabling interrupt mode (direct callback)\n"); + printf("[SIO] Data will be directly passed to callback in interrupt context\n"); +#endif + + printf("[SIO] Interrupt mode enabled successfully!\n"); + g_sio_interrupt_enabled = true; return ERRCODE_SUCC; } /** * @brief 禁用SIO中断模式 + * + * 根据 USE_SIO_PROCESS_THREAD 宏定义选择清理方式: + * - 定义了 USE_SIO_PROCESS_THREAD:清理缓冲区、队列和线程 + * - 未定义:仅清理 callback */ errcode_t sio_interrupt_disable(void) { @@ -757,6 +819,7 @@ errcode_t sio_interrupt_disable(void) printf("[SIO] Disabling interrupt mode\n"); +#ifdef USE_SIO_PROCESS_THREAD // 1. 停止定时器 if (g_sio_timer_running) { g_sio_timer_running = false; @@ -841,13 +904,16 @@ errcode_t sio_interrupt_disable(void) // 6. 清零统计 memset(&g_sio_stats, 0, sizeof(sio_stats_t)); +#else + printf("[SIO] Direct callback mode: no buffers/queues to clean up\n"); +#endif -#ifdef SUPPORT_PPP_SERVICE_INTERRUPT - // 7. 清理 CAT1 vote(如果之前添加过) +#ifdef SUPPORT_SLIP_SERVICE_INTERRUPT + // 清理 CAT1 vote(如果之前添加过) if (g_sio_cat1_vote_added) { + printf("[SIO_CAT1_VOTE] Removing vote during interrupt disable\n"); cat1_api_remove_cat1_vote(); g_sio_cat1_vote_added = false; - printf("[SIO] CAT1 vote removed during disable\n"); } g_sio_last_rx_time_ms = 0; #endif @@ -868,7 +934,7 @@ void sio_print_stats(void) { printf("=== SIO Interrupt Statistics (Ping-Pong Mode) ===\n"); printf("Interrupt Status: %s\n", g_sio_interrupt_enabled ? "ENABLED" : "DISABLED"); -#ifdef SUPPORT_PPP_SERVICE_INTERRUPT +#ifdef SUPPORT_SLIP_SERVICE_INTERRUPT printf("CAT1 Vote Status: %s\n", g_sio_cat1_vote_added ? "ADDED (awake)" : "REMOVED (sleep)"); if (g_sio_last_rx_time_ms > 0) { @@ -876,6 +942,7 @@ void sio_print_stats(void) printf("RX Idle Time: %u ms\n", idle_time); } #endif +#ifdef USE_SIO_PROCESS_THREAD printf("Ping-Pong Buffers: %d x %d bytes = %d KB total\n", SIO_PING_PONG_BUFFER_COUNT, SIO_PING_PONG_BUFFER_SIZE, (SIO_PING_PONG_BUFFER_COUNT * SIO_PING_PONG_BUFFER_SIZE) / 1024); @@ -912,7 +979,7 @@ void sio_print_stats(void) printf(" Cross-Buffer Writes: %u (跨buffer写入)\n", g_sio_stats.cross_buffer_count); printf(" Dropped (Both Full): %u bytes\n", g_sio_stats.dropped_both_full); printf("\n"); - +#endif // 中断层统计 printf("=== Interrupt Layer Statistics ===\n"); printf("Total UART Interrupts: %u\n", g_sio_stats.total_interrupts); @@ -944,8 +1011,46 @@ void sio_print_stats(void) printf(" Total Bytes Discarded: %u\n", g_sio_stats.dropped_both_full); printf("\n"); + // 计算速率(基于上次统计时间) + uint32_t current_time = sio_get_current_time_ms(); + uint32_t elapsed_ms = 0; + if (g_sio_stats.last_stat_time_ms > 0) { + elapsed_ms = current_time - g_sio_stats.last_stat_time_ms; + } else { + g_sio_stats.last_stat_time_ms = current_time; + g_sio_stats.last_bytes_received = g_sio_stats.total_bytes_received; + g_sio_stats.last_bytes_processed = g_sio_stats.total_bytes_processed; + } + + if (elapsed_ms > 0) { + uint32_t bytes_received_delta = g_sio_stats.total_bytes_received - g_sio_stats.last_bytes_received; + uint32_t bytes_processed_delta = g_sio_stats.total_bytes_processed - g_sio_stats.last_bytes_processed; + + uint32_t rx_rate_bps = (bytes_received_delta * 1000) / elapsed_ms; + uint32_t process_rate_bps = (bytes_processed_delta * 1000) / elapsed_ms; + + printf("Rate Statistics (last %u ms):\n", elapsed_ms); + printf(" RX Rate: %u bytes/s (%.2f KB/s)\n", + rx_rate_bps, rx_rate_bps / 1024.0f); + printf(" Process Rate: %u bytes/s (%.2f KB/s)\n", + process_rate_bps, process_rate_bps / 1024.0f); + + if (rx_rate_bps > 0) { + uint32_t process_efficiency = (process_rate_bps * 10000) / rx_rate_bps; + printf(" Process Efficiency: %u.%02u%%\n", + process_efficiency / 100, process_efficiency % 100); + } + printf("\n"); + + // 更新上次统计值 + g_sio_stats.last_stat_time_ms = current_time; + g_sio_stats.last_bytes_received = g_sio_stats.total_bytes_received; + g_sio_stats.last_bytes_processed = g_sio_stats.total_bytes_processed; + } + // 计算丢包率 if (g_sio_stats.total_bytes_received > 0) { +#ifdef USE_SIO_PROCESS_THREAD uint32_t drop_rate = (g_sio_stats.dropped_both_full * 10000) / g_sio_stats.total_bytes_received; printf("Total Drop Rate: %u.%02u%%\n", drop_rate / 100, drop_rate % 100); @@ -958,17 +1063,28 @@ void sio_print_stats(void) both_full_rate / 100, both_full_rate % 100); printf(" (processing too slow or buffers too small)\n"); } +#endif // 处理效率 - if (g_sio_stats.total_bytes_processed > 0) { - uint32_t process_rate = (g_sio_stats.total_bytes_processed * 10000) / - g_sio_stats.total_bytes_received; - printf("Process Success Rate: %u.%02u%%\n", - process_rate / 100, process_rate % 100); + // ⚠️ 修复整数溢出:当 total_bytes_processed > 429496 时,* 10000 会溢出 uint32_t + // 使用 uint64_t 进行计算,避免溢出 + if (g_sio_stats.total_bytes_processed > 0 && g_sio_stats.total_bytes_received > 0) { + uint64_t process_rate = ((uint64_t)g_sio_stats.total_bytes_processed * 10000ULL) / + (uint64_t)g_sio_stats.total_bytes_received; + // 限制在 0-10000 范围内(0.00% - 100.00%) + if (process_rate > 10000) { + process_rate = 10000; + } + printf("Process Success Rate: %llu.%02llu%%\n", + process_rate / 100ULL, process_rate % 100ULL); } } printf("=================================================\n"); + + // 打印SLIP解包统计 + printf("\n"); + slipif_print_stats(); } /** @@ -976,8 +1092,12 @@ void sio_print_stats(void) */ void sio_reset_stats(void) { - memset(&g_sio_stats, 0, sizeof(sio_stats_t)); - printf("[SIO] Statistics reset\n"); + uint32_t current_time = sio_get_current_time_ms(); + g_sio_stats.last_stat_time_ms = current_time; + g_sio_stats.last_bytes_received = g_sio_stats.total_bytes_received; + g_sio_stats.last_bytes_processed = g_sio_stats.total_bytes_processed; + // 注意:不重置累计值,只重置速率计算基准 + printf("[SIO] Statistics reset (rate calculation baseline updated)\n"); } /** diff --git a/code/sdk/open_source/openharmony/third_party/lwip/lwip_adapter/liteos/src/include/lwip/lwipopts_default.h b/code/sdk/open_source/openharmony/third_party/lwip/lwip_adapter/liteos/src/include/lwip/lwipopts_default.h index 0ec4bb52f..20f7b8ce4 100644 --- a/code/sdk/open_source/openharmony/third_party/lwip/lwip_adapter/liteos/src/include/lwip/lwipopts_default.h +++ b/code/sdk/open_source/openharmony/third_party/lwip/lwip_adapter/liteos/src/include/lwip/lwipopts_default.h @@ -44,7 +44,7 @@ extern "C" { #define LWIP_DEFINE_SWITCH 0 #define LOSCFG_CONFIG_MQTT 1 -#define LWIP_LOWPOWER 0 +#define LWIP_LOWPOWER 1 /* time unit */ #define MS_PER_SECOND 1000 @@ -708,7 +708,7 @@ extern "C" { #endif /* DEFAULT_LWIP_NUM_SOCKETS */ #ifndef MEMP_NUM_PBUF -#define MEMP_NUM_PBUF 8 +#define MEMP_NUM_PBUF 16 /* 增加以支持高负载场景 */ #endif #ifndef MEMP_NUM_RAW_PCB @@ -756,7 +756,7 @@ extern "C" { #endif #ifndef PBUF_POOL_SIZE -#define PBUF_POOL_SIZE 16 +#define PBUF_POOL_SIZE 128 /* 增加以支持高负载场景,防止 pbuf 耗尽 */ #endif #if defined (CONFIG_LWIP_FOR_WIFI_SIGMA) @@ -780,8 +780,38 @@ extern "C" { #define TCP_SND_QUEUELEN (TCP_SND_BUF / TCP_MSS) #endif +#define LWIP_DBG_PREPROCESSOR + #ifndef TCP_WND -#define TCP_WND (TCP_SND_BUF * 2 / 3) +/* TCP接收窗口大小:根据UART波特率自动计算 + * 计算公式:TCP_WND = (SIO_UART_BAUDRATE * 1425) / 80000 + * - UART理论速度 = SIO_UART_BAUDRATE / 8 (字节/秒) + * - SLIP开销:5%,实际可用速度 = 理论速度 × 0.95 + * - 网络RTT:150ms(移动网络) + * - 最小值:4KB (4096字节),最大值:64KB (65535字节),向下对齐到4KB边界(取下限) + */ +#ifndef SIO_UART_BAUDRATE +#define SIO_UART_BAUDRATE 921600 /* 默认波特率 */ +#endif +#define TCP_WND_CALCULATED ((SIO_UART_BAUDRATE * 1425) / 80000) +#define TCP_WND_CLAMPED_MIN ((TCP_WND_CALCULATED < 4096) ? 4096 : TCP_WND_CALCULATED) +#define TCP_WND_CLAMPED ((TCP_WND_CLAMPED_MIN > 65535) ? 65535 : TCP_WND_CLAMPED_MIN) +#define TCP_WND (TCP_WND_CLAMPED & ~4095) /* 向下对齐到4KB边界(取下限) */ +/* Note: TCP_WND is calculated from SIO_UART_BAUDRATE, clamped between 4KB-64KB, aligned down to 4KB */ +#ifdef LWIP_DBG_PREPROCESSOR +/* Display TCP_WND calculation info - show actual value for common baud rates */ +#if SIO_UART_BAUDRATE == 921600 +_Pragma("message(\"TCP_WND=16384 (16KB) calculated from SIO_UART_BAUDRATE=921600, formula: (baud*1425)/80000, clamped 4KB-64KB, aligned down to 4KB\")") +#elif SIO_UART_BAUDRATE == 1000000 +_Pragma("message(\"TCP_WND=16384 (16KB) calculated from SIO_UART_BAUDRATE=1000000, formula: (baud*1425)/80000, clamped 4KB-64KB, aligned down to 4KB\")") +#elif SIO_UART_BAUDRATE == 500000 +_Pragma("message(\"TCP_WND=8192 (8KB) calculated from SIO_UART_BAUDRATE=500000, formula: (baud*1425)/80000, clamped 4KB-64KB, aligned down to 4KB\")") +#elif SIO_UART_BAUDRATE == 115200 +_Pragma("message(\"TCP_WND=4096 (4KB) calculated from SIO_UART_BAUDRATE=115200, formula: (baud*1425)/80000, clamped 4KB-64KB, aligned down to 4KB\")") +#else +_Pragma("message(\"TCP_WND calculated from SIO_UART_BAUDRATE, formula: (baud*1425)/80000, clamped 4KB-64KB, aligned down to 4KB\")") +#endif +#endif #endif #ifndef LWIP_IGMP @@ -1228,6 +1258,8 @@ extern "C" { #define VALUE_TO_STRING(x) #x #define VALUE(x) VALUE_TO_STRING(x) #define VAR_NAME_VALUE(var) #var "=" VALUE(var) +/* Helper macro for pragma message using _Pragma operator */ +#define PRAGMA_MESSAGE_VAR(var) _Pragma("message(\"" #var "=\" " VALUE(var) "\")") #ifndef LWIP_CHKSUM_ALGORITHM #define LWIP_CHKSUM_ALGORITHM 3 @@ -1493,9 +1525,11 @@ extern unsigned int g_lwip_num_sockets; /* MEMP_NUM_PBUF: the number of memp struct pbufs. If the application sends a lot of data out of ROM (or other static memory), this - should be set high. */ + should be set high. + 增加以支持高负载场景,防止内存分配失败 + */ #ifndef MEMP_NUM_PBUF -#define MEMP_NUM_PBUF LWIP_CONFIG_NUM_SOCKETS*2 +#define MEMP_NUM_PBUF (LWIP_CONFIG_NUM_SOCKETS*2 + 16) /* 增加 16 个额外的 pbuf */ #endif /* @@ -1608,9 +1642,12 @@ extern unsigned int g_lwip_num_sockets; #endif /* ---------- Pbuf options ---------- */ -/** PBUF_POOL_SIZE: Indicates the number of buffers in the pbuf pool. */ +/** PBUF_POOL_SIZE: Indicates the number of buffers in the pbuf pool. + * 增加池大小以支持高负载场景(下载+文件写入),防止 pbuf 耗尽导致系统崩溃 + * 原值 64 在高负载下不足,增加到 128 + */ #ifndef PBUF_POOL_SIZE -#define PBUF_POOL_SIZE 64 +#define PBUF_POOL_SIZE 128 #endif /* PBUF_POOL_BUFSIZE: the size of each pbuf in the pbuf pool. */ @@ -1744,7 +1781,36 @@ TCP sender buffer space (pbufs). This must be at least = 2 * * Defines the size of a TCP receive window. */ #ifndef TCP_WND -#define TCP_WND 32768 +/* TCP接收窗口大小:根据UART波特率自动计算 + * 计算公式:TCP_WND = (SIO_UART_BAUDRATE * 1425) / 80000 + * - UART理论速度 = SIO_UART_BAUDRATE / 8 (字节/秒) + * - SLIP开销:5%,实际可用速度 = 理论速度 × 0.95 + * - 网络RTT:150ms(移动网络) + * - 最小值:4KB (4096字节),最大值:64KB (65535字节),向下对齐到4KB边界(取下限) + */ +#ifndef SIO_UART_BAUDRATE +#define SIO_UART_BAUDRATE 921600 /* 默认波特率 */ +#endif +#define TCP_WND_CALCULATED ((SIO_UART_BAUDRATE * 1425) / 80000) +#define TCP_WND_CLAMPED_MIN ((TCP_WND_CALCULATED < 4096) ? 4096 : TCP_WND_CALCULATED) +#define TCP_WND_CLAMPED ((TCP_WND_CLAMPED_MIN > 65535) ? 65535 : TCP_WND_CLAMPED_MIN) +#define TCP_WND (TCP_WND_CLAMPED & ~4095) /* 向下对齐到4KB边界(取下限) */ +/* Note: TCP_WND is calculated from SIO_UART_BAUDRATE, clamped between 4KB-64KB, aligned down to 4KB */ +#ifdef LWIP_DBG_PREPROCESSOR +/* Display TCP_WND calculation info - show actual value for common baud rates */ +#if SIO_UART_BAUDRATE == 921600 +_Pragma("message(\"TCP_WND=16384 (16KB) calculated from SIO_UART_BAUDRATE=921600, formula: (baud*1425)/80000, clamped 4KB-64KB, aligned down to 4KB\")") +#elif SIO_UART_BAUDRATE == 1000000 +_Pragma("message(\"TCP_WND=16384 (16KB) calculated from SIO_UART_BAUDRATE=1000000, formula: (baud*1425)/80000, clamped 4KB-64KB, aligned down to 4KB\")") +#elif SIO_UART_BAUDRATE == 500000 +_Pragma("message(\"TCP_WND=8192 (8KB) calculated from SIO_UART_BAUDRATE=500000, formula: (baud*1425)/80000, clamped 4KB-64KB, aligned down to 4KB\")") +#elif SIO_UART_BAUDRATE == 115200 +_Pragma("message(\"TCP_WND=4096 (4KB) calculated from SIO_UART_BAUDRATE=115200, formula: (baud*1425)/80000, clamped 4KB-64KB, aligned down to 4KB\")") +#else +_Pragma("message(\"TCP_WND calculated from SIO_UART_BAUDRATE, formula: (baud*1425)/80000, clamped 4KB-64KB, aligned down to 4KB\")") +#endif +#endif + #endif /** diff --git a/code/sdk/open_source/openharmony/third_party/lwip/lwip_v2.1.3/src/apps/altcp_tls/altcp_tls_mbedtls.c b/code/sdk/open_source/openharmony/third_party/lwip/lwip_v2.1.3/src/apps/altcp_tls/altcp_tls_mbedtls.c index 47d5d2200..1518b48d7 100644 --- a/code/sdk/open_source/openharmony/third_party/lwip/lwip_v2.1.3/src/apps/altcp_tls/altcp_tls_mbedtls.c +++ b/code/sdk/open_source/openharmony/third_party/lwip/lwip_v2.1.3/src/apps/altcp_tls/altcp_tls_mbedtls.c @@ -391,6 +391,19 @@ altcp_mbedtls_handle_rx_appldata(struct altcp_pcb *conn, altcp_mbedtls_state_t * /* client is initiating a new connection using the same source port -> close connection or make handshake */ LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("new connection on same source port\n")); LWIP_ASSERT("TODO: new connection on same source port, close this connection", 0); + } else if (ret == MBEDTLS_ERR_SSL_TIMEOUT) { + /* SSL read timeout - may occur on slow links (e.g., UART SLIP) + * If there's data in the RX buffer, retry instead of closing the connection */ + if (state->rx != NULL) { + /* There's data pending, retry on next call */ + LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("SSL read timeout but data pending, retry later\n")); + pbuf_free(buf); + return ERR_OK; + } + /* No data pending, may be a real timeout */ + LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("SSL read timeout, no data pending\n")); + pbuf_free(buf); + return ERR_OK; } else if ((ret != MBEDTLS_ERR_SSL_WANT_READ) && (ret != MBEDTLS_ERR_SSL_WANT_WRITE)) { if (ret == MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY) { LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("connection was closed gracefully\n")); diff --git a/code/sdk/open_source/openharmony/third_party/lwip/lwip_v2.1.3/src/netif/slipif.c b/code/sdk/open_source/openharmony/third_party/lwip/lwip_v2.1.3/src/netif/slipif.c index a8a09afae..e0a1ac933 100644 --- a/code/sdk/open_source/openharmony/third_party/lwip/lwip_v2.1.3/src/netif/slipif.c +++ b/code/sdk/open_source/openharmony/third_party/lwip/lwip_v2.1.3/src/netif/slipif.c @@ -75,6 +75,9 @@ #include #include #include "custom_utils.h" +#if LWIP_LOWPOWER +#include "lwip/netifapi.h" +#endif static app_task_definition_t taskcfg={0}; @@ -105,6 +108,46 @@ enum slipif_recv_state { SLIP_RECV_ESCAPE }; +/* 网络吞吐速率统计和低功耗控制 */ +#if LWIP_LOWPOWER +/* 速率统计窗口时间(毫秒) */ +#define SLIP_RATE_STAT_WINDOW_MS 1000 /* 1秒统计窗口 */ +/* 低功耗切换阈值(字节/秒) */ +#define SLIP_LOWPOWER_THRESHOLD_BPS 1024 /* 低于1KB/s认为空闲,进入低功耗 */ +/* 低功耗状态检查间隔(毫秒) */ +#define SLIP_LOWPOWER_CHECK_INTERVAL_MS 5000 /* 每5秒检查一次 */ + +struct slip_rate_stat { + u32_t rx_bytes; /* 接收字节数(统计窗口内) */ + u32_t tx_bytes; /* 发送字节数(统计窗口内) */ + u32_t rx_packets; /* 接收包数(统计窗口内) */ + u32_t tx_packets; /* 发送包数(统计窗口内) */ + u32_t window_start_ms; /* 统计窗口开始时间 */ + u8_t lowpower_enabled; /* 当前低功耗状态 */ + u32_t last_check_ms; /* 上次检查时间 */ +}; + +static struct slip_rate_stat g_slip_rate_stat = {0}; +#endif /* LWIP_LOWPOWER */ + +/* SLIP解包错误统计 */ +struct slipif_error_stats { + u32_t pbuf_alloc_fail_count; /* pbuf分配失败次数 */ + u32_t packet_too_large_count; /* 包太大丢弃次数 */ + u32_t invalid_escape_count; /* 无效转义序列次数 */ + u32_t netif_input_fail_count; /* netif->input失败次数 */ + u32_t queue_corrupted_count; /* 队列损坏次数 */ + u32_t bytes_dropped; /* 丢弃的总字节数 */ + u32_t packets_dropped; /* 丢弃的总包数 */ + u32_t packets_received; /* 成功接收的包数 */ + u32_t bytes_received; /* 成功接收的字节数 */ + u32_t last_stat_time_ms; /* 上次统计时间(用于计算速率) */ + u32_t last_bytes_received; /* 上次统计时的接收字节数(用于计算速率) */ + u32_t last_packets_received; /* 上次统计时的接收包数(用于计算速率) */ +}; + +static struct slipif_error_stats g_slipif_error_stats = {0}; + struct slipif_priv { sio_fd_t sd; /* q is the whole pbuf chain for a packet, p is the current pbuf in the chain */ @@ -114,17 +157,33 @@ struct slipif_priv { #if SLIP_RX_FROM_ISR struct pbuf *rxpackets; sys_mutex_t rxqueue_mutex; // 接收队列互斥锁 + sys_sem_t rx_data_sem; // 数据到达信号量(用于功耗优化) #endif }; static void slipif_rxbyte_input(struct netif *netif, u8_t c); +/* SLIP统计打印函数声明 */ +void slipif_print_stats(void); + +#if LWIP_LOWPOWER +/* 更新接收速率统计 */ +static void slipif_update_rx_rate(u32_t bytes); +/* 更新发送速率统计 */ +static void slipif_update_tx_rate(u32_t bytes); +/* 检查并切换低功耗模式 */ +static void slipif_check_and_switch_lowpower(void); +#endif /* LWIP_LOWPOWER */ + /* Global variable to store slipif_loop_thread ID */ // static sys_thread_t slipif_loop_thread_id = 0xffffffffU; /* Event flag for thread control */ static volatile bool slipif_thread_running = true; +/* Thread creation flag to prevent duplicate thread creation */ +static volatile bool slipif_thread_created = false; + /* Global variable to store current netif */ static struct netif *g_current_slipif_netif = NULL; @@ -212,6 +271,15 @@ slipif_output(struct netif *netif, struct pbuf *p) priv = (struct slipif_priv *)netif->state; LWIP_DEBUGF(SLIP_DEBUG, ("slipif_output: priv=%p, sd=%p\n", priv, priv->sd)); +#if LWIP_LOWPOWER + /* 发送数据前,确保网络不在低功耗模式(确保实时响应) */ + if (g_slip_rate_stat.lowpower_enabled != 0) { + LWIP_DEBUGF(SLIP_DEBUG, ("[SLIP_LOWPOWER] Disabling lowpower mode before sending data\n")); + netifapi_disable_lowpower(); + g_slip_rate_stat.lowpower_enabled = 0; + } +#endif + /* Send pbuf out on the serial I/O device. */ #ifdef SUPPORT_CAT1_SERVICE @@ -268,6 +336,12 @@ slipif_output(struct netif *netif, struct pbuf *p) LWIP_DEBUGF(SLIP_DEBUG, ("slipif_output: transmission complete, total_bytes=%d, escaped_bytes=%d\n", total_bytes, escaped_bytes)); +#if LWIP_LOWPOWER + /* 更新发送速率统计(包含SLIP编码开销:SLIP_END + escaped_bytes + SLIP_END) */ + u32_t tx_total = total_bytes + escaped_bytes + 2; /* +2 for SLIP_END markers */ + slipif_update_tx_rate(tx_total); +#endif + return ERR_OK; } @@ -375,6 +449,7 @@ slipif_rxbyte(struct netif *netif, u8_t c) break; default: LWIP_DEBUGF(SLIP_DEBUG, ("slipif_rxbyte: invalid escape sequence 0x%02x, returning to normal mode\n", c)); + g_slipif_error_stats.invalid_escape_count++; priv->state = SLIP_RECV_NORMAL; return c; } @@ -388,6 +463,8 @@ slipif_rxbyte(struct netif *netif, u8_t c) priv->p = pbuf_alloc(PBUF_LINK, (PBUF_POOL_BUFSIZE - PBUF_LINK_HLEN - PBUF_LINK_ENCAPSULATION_HLEN), PBUF_POOL); if (priv->p == NULL) { LWIP_DEBUGF(SLIP_DEBUG, ("slipif_rxbyte: pbuf allocation failed!\n")); + g_slipif_error_stats.pbuf_alloc_fail_count++; + g_slipif_error_stats.packets_dropped++; return c; } LWIP_DEBUGF(SLIP_DEBUG, ("slipif_rxbyte: pbuf allocated successfully, p=%p\n", priv->p)); @@ -397,6 +474,9 @@ slipif_rxbyte(struct netif *netif, u8_t c) if (priv->i >= SLIP_MAX_SIZE) { LWIP_DEBUGF(SLIP_DEBUG, ("slipif_rxbyte: packet too large (%d >= %d), dropping\n", priv->i, SLIP_MAX_SIZE)); + g_slipif_error_stats.packet_too_large_count++; + g_slipif_error_stats.packets_dropped++; + g_slipif_error_stats.bytes_dropped += priv->recved; pbuf_free(priv->q); priv->p = priv->q = NULL; priv->i = priv->recved = 0; @@ -419,6 +499,9 @@ slipif_rxbyte(struct netif *netif, u8_t c) priv->i = 0; } else { LWIP_DEBUGF(SLIP_DEBUG, ("slipif_rxbyte: next pbuf allocation failed, dropping packet\n")); + g_slipif_error_stats.pbuf_alloc_fail_count++; + g_slipif_error_stats.packets_dropped++; + g_slipif_error_stats.bytes_dropped += priv->recved; pbuf_free(priv->q); priv->p = priv->q = NULL; priv->i = priv->recved = 0; @@ -456,8 +539,13 @@ slipif_rxbyte_input(struct netif *netif, u8_t c) p = slipif_rxbyte(netif, c); if (p != NULL) { LWIP_DEBUGF(SLIP_DEBUG, ("slipif_rxbyte_input: complete packet received, length=%d\n", p->tot_len)); + g_slipif_error_stats.packets_received++; + g_slipif_error_stats.bytes_received += p->tot_len; if (netif->input(p, netif) != ERR_OK) { LWIP_DEBUGF(SLIP_DEBUG, ("slipif_rxbyte_input: netif->input failed, freeing pbuf\n")); + g_slipif_error_stats.netif_input_fail_count++; + g_slipif_error_stats.packets_dropped++; + g_slipif_error_stats.bytes_dropped += p->tot_len; pbuf_free(p); } else { LWIP_DEBUGF(SLIP_DEBUG, ("slipif_rxbyte_input: packet sent to IP layer successfully\n")); @@ -504,23 +592,35 @@ slipif_loop_thread(void *nf) LOS_Msleep(2000); /* 使用系统级休眠,让系统能够进入深度休眠 */ continue; } - // printf("slipif_loop_thread \n"); + #if SLIP_RX_FROM_ISR - /* 处理接收队列 */ - u16_t processed_count = slipif_process_rxqueue(netif); + /* 功耗优化:使用信号量事件驱动,而非轮询 */ + /* 等待数据到达信号量,最多等待500ms超时(避免长时间阻塞) */ + u32_t wait_result = sys_arch_sem_wait(&priv->rx_data_sem, 500); - /* 简化的休眠策略:根据处理结果决定休眠时间 */ - if (processed_count == 0) { - /* 没有数据包处理,长时间休眠 */ - LOS_Msleep(50); /* 50ms休眠,减少CPU占用 */ - } else if (processed_count < 5) { - /* 处理少量数据包,中等时间休眠 */ - LOS_Msleep(20); /* 20ms休眠 */ + if (wait_result == SYS_ARCH_TIMEOUT) { + /* 超时:检查是否有残留数据(可能信号量丢失或队列中还有数据) */ + u16_t processed = slipif_process_rxqueue(netif); + if (processed == 0) { + /* 真正空闲:继续等待,不消耗CPU */ + continue; + } + /* 有残留数据:继续处理 */ } else { - /* 处理大量数据包,短暂休眠 */ - LOS_Msleep(5); /* 5ms休眠 */ + /* 信号量触发:有数据到达,处理队列 */ + u16_t processed_count = slipif_process_rxqueue(netif); + + /* 如果处理了数据包,继续处理队列直到清空(批量处理提高效率) */ + while (processed_count > 0) { + processed_count = slipif_process_rxqueue(netif); + /* 如果队列还有数据,继续处理(不休眠) */ + if (processed_count == 0) { + break; // 队列已清空,退出循环等待下一个信号量 + } + } } #else + /* 非ISR模式:使用轮询(因为直接处理,不需要队列和信号量) */ if (sio_tryread(priv->sd, &c, 1) > 0) { LWIP_DEBUGF(SLIP_DEBUG, ("slipif_loop_thread: received byte 0x%02x\n", c)); slipif_rxbyte_input(netif, c); @@ -581,6 +681,14 @@ slipif_init(struct netif *netif) mem_free(priv); return ERR_MEM; } + // 创建数据到达信号量(初始值为0,用于事件驱动) + if (sys_sem_new(&priv->rx_data_sem, 0) != ERR_OK) { + LWIP_DEBUGF(SLIP_DEBUG, ("ERROR: slipif_init: failed to create rx_data_sem\n")); + sys_mutex_free(&priv->rxqueue_mutex); + mem_free(priv); + return ERR_MEM; + } + LWIP_DEBUGF(SLIP_DEBUG, ("slipif_init: rx_data_sem created for power optimization\n")); #endif LWIP_DEBUGF(SLIP_DEBUG, ("slipif_init: netif configured, name=%c%c, flags=0x%x\n", @@ -592,6 +700,7 @@ slipif_init(struct netif *netif) /* opening the serial device failed, free priv and return */ printf("ERROR: slipif_init: sio_open failed for SLIP_IFNUM=%d\n", SLIP_IFNUM); #if SLIP_RX_FROM_ISR + sys_sem_free(&priv->rx_data_sem); sys_mutex_free(&priv->rxqueue_mutex); #endif mem_free(priv); @@ -602,37 +711,81 @@ slipif_init(struct netif *netif) /* 设置全局netif供SIO回调使用 */ slipif_set_current_netif(netif); +#if LWIP_LOWPOWER + /* 初始化统计结构,确保网络启动时不在低功耗模式 */ + u32_t now = sys_now(); + g_slip_rate_stat.window_start_ms = now; + g_slip_rate_stat.last_check_ms = now; + g_slip_rate_stat.lowpower_enabled = 0; /* 初始状态:网络活跃 */ + g_slip_rate_stat.rx_bytes = 0; + g_slip_rate_stat.tx_bytes = 0; + g_slip_rate_stat.rx_packets = 0; + g_slip_rate_stat.tx_packets = 0; + /* 确保初始状态不在低功耗模式 */ + netifapi_disable_lowpower(); + LWIP_DEBUGF(SLIP_DEBUG, ("slipif_init: initialized rate statistics, lowpower disabled\n")); +#endif + /* 启用SIO乒乓buffer中断模式 */ printf("[SLIP] Enabling SIO ping-pong buffer interrupt mode...\n"); errcode_t ret_sio = sio_interrupt_enable(slipif_sio_data_callback); if (ret_sio != ERRCODE_SUCC) { printf("[SLIP] WARNING: sio_interrupt_enable failed: 0x%x, falling back to polling mode\n", ret_sio); + /* 中断模式失败,必须创建线程进行轮询 */ +#if SLIP_USE_RX_THREAD + /* 检查线程是否已经创建,避免重复创建 */ + if (!slipif_thread_created) { + /* Create a thread to poll the serial device. */ + LWIP_DEBUGF(SLIP_DEBUG, ("slipif_init: creating RX thread (polling mode) with stack=%d, prio=%d\n", + SLIP_RX_THREAD_STACKSIZE, SLIP_RX_THREAD_PRIO)); + taskcfg.create_queue_handle = NULL; + taskcfg.attr.name = SLIP_RX_THREAD_NAME; + taskcfg.attr.priority = osPriorityBelowNormal; + taskcfg.attr.stack_size = SLIP_RX_THREAD_STACKSIZE; + taskcfg.func = slipif_loop_thread; + taskcfg.use_mem = USE_EXTEND_MEM; + + errcode_t ret = uapi_create_osThread_custom(&taskcfg); + if (ret != ERRCODE_SUCC) { + printf("create slipif_loop_thread failed %d\n", ret); + } else { + printf("create slipif_loop_thread succed (polling mode)\n"); + slipif_thread_created = true; + } + } else { + printf("[SLIP] RX thread already created, skipping (polling mode)\n"); + } +#endif /* SLIP_USE_RX_THREAD */ } else { printf("[SLIP] SIO ping-pong buffer enabled successfully!\n"); // printf("[SLIP] Data flow: UART ISR -> ping-pong buffer -> SIO callback -> SLIP parser\n"); - } -#if SLIP_USE_RX_THREAD - /* Create a thread to poll the serial device. */ - LWIP_DEBUGF(SLIP_DEBUG, ("slipif_init: creating RX thread with stack=%d, prio=%d\n", - SLIP_RX_THREAD_STACKSIZE, SLIP_RX_THREAD_PRIO)); - - - // slipif_loop_thread_id = sys_thread_new(SLIP_RX_THREAD_NAME, slipif_loop_thread, netif, - // SLIP_RX_THREAD_STACKSIZE, SLIP_RX_THREAD_PRIO); - taskcfg.create_queue_handle = NULL; - taskcfg.attr.name=SLIP_RX_THREAD_NAME; - taskcfg.attr.priority = osPriorityBelowNormal;// osPriorityBelowNormal; - taskcfg.attr.stack_size = SLIP_RX_THREAD_STACKSIZE; - taskcfg.func = slipif_loop_thread; - taskcfg.use_mem = USE_EXTEND_MEM; - errcode_t ret=uapi_create_osThread_custom(&taskcfg); - if(ret != ERRCODE_SUCC) - printf("create slipif_loop_thread failed %d\n",ret); - else - printf("create slipif_loop_thread succed\n"); - -#endif /* SLIP_USE_RX_THREAD */ +#if SLIP_RX_FROM_ISR && SLIP_USE_RX_THREAD + /* 中断模式成功,但如果使用了ISR队列模式,仍需要创建线程来处理队列 */ + /* 因为回调函数会将数据放入队列,需要线程调用 slipif_process_rxqueue 处理 */ + /* 检查线程是否已经创建,避免重复创建 */ + if (!slipif_thread_created) { + LWIP_DEBUGF(SLIP_DEBUG, ("slipif_init: creating RX thread (ISR queue mode) with stack=%d, prio=%d\n", + SLIP_RX_THREAD_STACKSIZE, SLIP_RX_THREAD_PRIO)); + taskcfg.create_queue_handle = NULL; + taskcfg.attr.name = SLIP_RX_THREAD_NAME; + taskcfg.attr.priority = osPriorityBelowNormal; + taskcfg.attr.stack_size = SLIP_RX_THREAD_STACKSIZE; + taskcfg.func = slipif_loop_thread; + taskcfg.use_mem = USE_EXTEND_MEM; + + errcode_t ret = uapi_create_osThread_custom(&taskcfg); + if (ret != ERRCODE_SUCC) { + printf("[SLIP] ERROR: create slipif_loop_thread failed %d (ISR queue mode)\n", ret); + } else { + printf("[SLIP] create slipif_loop_thread succed (ISR queue mode)\n"); + slipif_thread_created = true; + } + } else { + printf("[SLIP] RX thread already created, skipping (ISR queue mode)\n"); + } +#endif /* SLIP_RX_FROM_ISR && SLIP_USE_RX_THREAD */ + } LWIP_DEBUGF(SLIP_DEBUG, ("slipif_init: initialization completed successfully\n")); return ERR_OK; @@ -762,6 +915,7 @@ slipif_process_rxqueue(struct netif *netif) if (priv->rxpackets != NULL) { if (!slipif_check_rxqueue_integrity(netif)) { LWIP_DEBUGF(SLIP_DEBUG, ("ERROR: slipif_process_rxqueue: queue integrity check failed, cleaning up\n")); + g_slipif_error_stats.queue_corrupted_count++; slipif_cleanup_corrupted_rxqueue(netif); sys_mutex_unlock(&priv->rxqueue_mutex); return 0; // 返回0表示没有处理任何数据包 @@ -798,8 +952,13 @@ slipif_process_rxqueue(struct netif *netif) /* 释放锁,避免在 netif->input 中长时间持有锁 */ sys_mutex_unlock(&priv->rxqueue_mutex); + g_slipif_error_stats.packets_received++; + g_slipif_error_stats.bytes_received += q->tot_len; if (netif->input(q, netif) != ERR_OK) { LWIP_DEBUGF(SLIP_DEBUG, ("slipif_process_rxqueue: netif->input failed, freeing pbuf\n")); + g_slipif_error_stats.netif_input_fail_count++; + g_slipif_error_stats.packets_dropped++; + g_slipif_error_stats.bytes_dropped += q->tot_len; pbuf_free(q); } else { // LWIP_DEBUGF(SLIP_DEBUG, ("slipif_process_rxqueue: packet sent to IP layer successfully\n")); @@ -883,7 +1042,21 @@ slipif_rxbyte_enqueue(struct netif *netif, u8_t data) priv->rxpackets = p; sys_mutex_unlock(&priv->rxqueue_mutex); - LWIP_DEBUGF(SLIP_DEBUG, ("slipif_rxbyte_enqueue: enqueued pbuf 0x%p, rxpackets now 0x%p\n", p, priv->rxpackets)); + /* 触发信号量,唤醒处理线程(功耗优化:事件驱动而非轮询) */ + sys_sem_signal(&priv->rx_data_sem); + +#if LWIP_LOWPOWER + /* 接收到数据时,确保网络不在低功耗模式(确保实时响应) */ + if (g_slip_rate_stat.lowpower_enabled != 0) { + LWIP_DEBUGF(SLIP_DEBUG, ("[SLIP_LOWPOWER] Disabling lowpower mode upon receiving data\n")); + netifapi_disable_lowpower(); + g_slip_rate_stat.lowpower_enabled = 0; + } + /* 更新接收速率统计 */ + slipif_update_rx_rate(p->tot_len); +#endif + + LWIP_DEBUGF(SLIP_DEBUG, ("slipif_rxbyte_enqueue: enqueued pbuf 0x%p, rxpackets now 0x%p, sem signaled\n", p, priv->rxpackets)); } } @@ -1001,4 +1174,223 @@ slipif_loop_thread_resume(void) printf("slipif_loop_thread resume succed\n"); } return 0; -} +} + +#if LWIP_LOWPOWER +/** + * @brief 更新接收速率统计 + * @param bytes 接收的字节数 + */ +static void +slipif_update_rx_rate(u32_t bytes) +{ + u32_t now = sys_now(); + u32_t elapsed; + + /* 初始化统计窗口 */ + if (g_slip_rate_stat.window_start_ms == 0) { + g_slip_rate_stat.window_start_ms = now; + g_slip_rate_stat.last_check_ms = now; + g_slip_rate_stat.lowpower_enabled = 0; + } + + /* 检查是否需要重置统计窗口 */ + elapsed = now - g_slip_rate_stat.window_start_ms; + if (elapsed >= SLIP_RATE_STAT_WINDOW_MS) { + /* 窗口过期,重置统计 */ + g_slip_rate_stat.rx_bytes = 0; + g_slip_rate_stat.tx_bytes = 0; + g_slip_rate_stat.rx_packets = 0; + g_slip_rate_stat.tx_packets = 0; + g_slip_rate_stat.window_start_ms = now; + } + + /* 更新接收统计 */ + g_slip_rate_stat.rx_bytes += bytes; + g_slip_rate_stat.rx_packets++; + + /* 检查是否需要切换低功耗模式 */ + elapsed = now - g_slip_rate_stat.last_check_ms; + if (elapsed >= SLIP_LOWPOWER_CHECK_INTERVAL_MS) { + slipif_check_and_switch_lowpower(); + g_slip_rate_stat.last_check_ms = now; + } +} + +/** + * @brief 更新发送速率统计 + * @param bytes 发送的字节数(包含SLIP编码开销) + */ +static void +slipif_update_tx_rate(u32_t bytes) +{ + u32_t now = sys_now(); + u32_t elapsed; + + /* 初始化统计窗口 */ + if (g_slip_rate_stat.window_start_ms == 0) { + g_slip_rate_stat.window_start_ms = now; + g_slip_rate_stat.last_check_ms = now; + g_slip_rate_stat.lowpower_enabled = 0; + } + + /* 检查是否需要重置统计窗口 */ + elapsed = now - g_slip_rate_stat.window_start_ms; + if (elapsed >= SLIP_RATE_STAT_WINDOW_MS) { + /* 窗口过期,重置统计 */ + g_slip_rate_stat.rx_bytes = 0; + g_slip_rate_stat.tx_bytes = 0; + g_slip_rate_stat.rx_packets = 0; + g_slip_rate_stat.tx_packets = 0; + g_slip_rate_stat.window_start_ms = now; + } + + /* 更新发送统计 */ + g_slip_rate_stat.tx_bytes += bytes; + g_slip_rate_stat.tx_packets++; + + /* 检查是否需要切换低功耗模式 */ + elapsed = now - g_slip_rate_stat.last_check_ms; + if (elapsed >= SLIP_LOWPOWER_CHECK_INTERVAL_MS) { + slipif_check_and_switch_lowpower(); + g_slip_rate_stat.last_check_ms = now; + } +} + +/** + * @brief 检查网络吞吐速率并动态切换低功耗模式 + * + * 根据接收和发送数据速率综合判断网络活动状态: + * - 如果总吞吐速率低于阈值,进入低功耗模式 + * - 如果总吞吐速率高于阈值,退出低功耗模式 + */ +static void +slipif_check_and_switch_lowpower(void) +{ + u32_t now = sys_now(); + u32_t elapsed; + u32_t total_bytes; + u32_t throughput_bps; /* 吞吐速率(字节/秒) */ + err_t ret; + + /* 检查统计窗口是否已初始化 */ + if (g_slip_rate_stat.window_start_ms == 0) { + /* 统计窗口未初始化,不进行低功耗切换 */ + LWIP_DEBUGF(SLIP_DEBUG, ("[SLIP_LOWPOWER] Statistics window not initialized, skipping check\n")); + return; + } + + /* 计算统计窗口内的实际时间 */ + elapsed = now - g_slip_rate_stat.window_start_ms; + + /* 如果窗口刚重置或时间不够,延迟低功耗切换(避免误判) */ + if (elapsed < (SLIP_RATE_STAT_WINDOW_MS / 2)) { + /* 窗口时间不足一半,不进行低功耗切换,避免误判 */ + LWIP_DEBUGF(SLIP_DEBUG, ("[SLIP_LOWPOWER] Window time too short (%u ms < %u ms), skipping check\n", + elapsed, SLIP_RATE_STAT_WINDOW_MS / 2)); + return; + } + + if (elapsed > SLIP_RATE_STAT_WINDOW_MS) { + elapsed = SLIP_RATE_STAT_WINDOW_MS; /* 使用窗口大小作为基准 */ + } + + /* 计算总吞吐量(接收+发送) */ + total_bytes = g_slip_rate_stat.rx_bytes + g_slip_rate_stat.tx_bytes; + + /* 计算吞吐速率(字节/秒) */ + throughput_bps = (total_bytes * 1000) / elapsed; + + LWIP_DEBUGF(SLIP_DEBUG, ("[SLIP_LOWPOWER] Check: rx=%u, tx=%u, total=%u bytes, elapsed=%u ms, throughput=%u B/s\n", + g_slip_rate_stat.rx_bytes, g_slip_rate_stat.tx_bytes, + total_bytes, elapsed, throughput_bps)); + + /* 根据吞吐速率判断是否需要切换低功耗模式 */ + if (throughput_bps < SLIP_LOWPOWER_THRESHOLD_BPS) { + /* 网络空闲:进入低功耗模式 */ + if (g_slip_rate_stat.lowpower_enabled == 0) { + LWIP_DEBUGF(SLIP_DEBUG, ("[SLIP_LOWPOWER] Network idle (throughput=%u B/s < %u B/s), enabling lowpower mode\n", + throughput_bps, SLIP_LOWPOWER_THRESHOLD_BPS)); + ret = netifapi_enable_lowpower(); + if (ret == ERR_OK) { + g_slip_rate_stat.lowpower_enabled = 1; + LWIP_DEBUGF(SLIP_DEBUG, ("[SLIP_LOWPOWER] Lowpower mode enabled successfully\n")); + } else { + LWIP_DEBUGF(SLIP_DEBUG, ("[SLIP_LOWPOWER] Failed to enable lowpower mode: %d\n", ret)); + } + } + } else { + /* 网络活跃:退出低功耗模式 */ + if (g_slip_rate_stat.lowpower_enabled == 1) { + LWIP_DEBUGF(SLIP_DEBUG, ("[SLIP_LOWPOWER] Network active (throughput=%u B/s >= %u B/s), disabling lowpower mode\n", + throughput_bps, SLIP_LOWPOWER_THRESHOLD_BPS)); + ret = netifapi_disable_lowpower(); + if (ret == ERR_OK) { + g_slip_rate_stat.lowpower_enabled = 0; + LWIP_DEBUGF(SLIP_DEBUG, ("[SLIP_LOWPOWER] Lowpower mode disabled successfully\n")); + } else { + LWIP_DEBUGF(SLIP_DEBUG, ("[SLIP_LOWPOWER] Failed to disable lowpower mode: %d\n", ret)); + } + } + } +} +#endif /* LWIP_LOWPOWER */ + +/** + * @brief 打印SLIP解包错误统计信息 + */ +void slipif_print_stats(void) +{ + u32_t now = sys_now(); + u32_t elapsed_ms = 0; + u32_t rx_rate_bps = 0; + u32_t drop_rate_percent = 0; + + if (g_slipif_error_stats.last_stat_time_ms > 0) { + elapsed_ms = now - g_slipif_error_stats.last_stat_time_ms; + } else { + g_slipif_error_stats.last_stat_time_ms = now; + g_slipif_error_stats.last_bytes_received = g_slipif_error_stats.bytes_received; + g_slipif_error_stats.last_packets_received = g_slipif_error_stats.packets_received; + } + + printf("=== SLIP Decoding Statistics ===\n"); + printf("Packets Received: %u\n", g_slipif_error_stats.packets_received); + printf("Bytes Received: %u\n", g_slipif_error_stats.bytes_received); + printf("Packets Dropped: %u\n", g_slipif_error_stats.packets_dropped); + printf("Bytes Dropped: %u\n", g_slipif_error_stats.bytes_dropped); + + /* 计算接收速率(基于增量) */ + if (elapsed_ms > 0) { + u32_t bytes_delta = g_slipif_error_stats.bytes_received - g_slipif_error_stats.last_bytes_received; + u32_t packets_delta = g_slipif_error_stats.packets_received - g_slipif_error_stats.last_packets_received; + + if (bytes_delta > 0) { + rx_rate_bps = (bytes_delta * 1000) / elapsed_ms; + printf("RX Rate (last %u ms): %u bytes/s (%.2f KB/s), %u packets/s\n", + elapsed_ms, rx_rate_bps, rx_rate_bps / 1024.0f, + (packets_delta * 1000) / elapsed_ms); + } + } + + /* 计算丢包率 */ + u32_t total_packets = g_slipif_error_stats.packets_received + g_slipif_error_stats.packets_dropped; + if (total_packets > 0) { + drop_rate_percent = (g_slipif_error_stats.packets_dropped * 10000) / total_packets; + printf("Drop Rate: %u.%02u%%\n", drop_rate_percent / 100, drop_rate_percent % 100); + } + + printf("\nError Details:\n"); + printf(" pbuf Allocation Failures: %u\n", g_slipif_error_stats.pbuf_alloc_fail_count); + printf(" Packets Too Large: %u\n", g_slipif_error_stats.packet_too_large_count); + printf(" Invalid Escape Sequences: %u\n", g_slipif_error_stats.invalid_escape_count); + printf(" netif->input Failures: %u\n", g_slipif_error_stats.netif_input_fail_count); + printf(" Queue Corrupted: %u\n", g_slipif_error_stats.queue_corrupted_count); + + printf("=================================================\n"); + + /* 更新统计时间戳和基准值 */ + g_slipif_error_stats.last_stat_time_ms = now; + g_slipif_error_stats.last_bytes_received = g_slipif_error_stats.bytes_received; + g_slipif_error_stats.last_packets_received = g_slipif_error_stats.packets_received; +} diff --git a/code/sdk/zhihui/4g/cat1Service/CMakeLists.txt b/code/sdk/zhihui/4g/cat1Service/CMakeLists.txt index 691a92a79..53293b8e5 100644 --- a/code/sdk/zhihui/4g/cat1Service/CMakeLists.txt +++ b/code/sdk/zhihui/4g/cat1Service/CMakeLists.txt @@ -62,7 +62,7 @@ set(PUBLIC_DEFINES SLIP_MODULE_ENABLED=1 LWIP_SLIP=1 SLIP_SUPPORT=1 - SLIP_USE_RX_THREAD=1 + SLIP_USE_RX_THREAD=1 #是否使用单独的queue和thread处理slip数据 SLIP_RX_FROM_ISR=1 SLIP_IFNUM=0 ) diff --git a/code/sdk/zhihui/4g/cat1Service/Service/cat1_utils.c b/code/sdk/zhihui/4g/cat1Service/Service/cat1_utils.c index 74ef96daa..028f29bd5 100644 --- a/code/sdk/zhihui/4g/cat1Service/Service/cat1_utils.c +++ b/code/sdk/zhihui/4g/cat1Service/Service/cat1_utils.c @@ -384,10 +384,10 @@ errcode_t cat1_register_time_ctl_functions(time_ctl_funcs_t *funcs) void cat1_api_suspend_protocol(void) { - #ifdef SUPPORT_LWIP - tcpip_thread_suspend(); - slipif_loop_thread_suspend(); - #endif + // #ifdef SUPPORT_LWIP + // tcpip_thread_suspend(); + // slipif_loop_thread_suspend(); + // #endif } /** @@ -403,10 +403,10 @@ void cat1_api_suspend_protocol(void) */ void cat1_api_resume_protocol(void) { - #ifdef SUPPORT_LWIP - tcpip_thread_resume(); - slipif_loop_thread_resume(); - #endif + // #ifdef SUPPORT_LWIP + // tcpip_thread_resume(); + // slipif_loop_thread_resume(); + // #endif } diff --git a/code/sdk/zhihui/4g/cat1Service/include/cat1_porting.h b/code/sdk/zhihui/4g/cat1Service/include/cat1_porting.h index 6056377cf..a87d82759 100644 --- a/code/sdk/zhihui/4g/cat1Service/include/cat1_porting.h +++ b/code/sdk/zhihui/4g/cat1Service/include/cat1_porting.h @@ -25,6 +25,18 @@ void cat1_api_remove_cat1_vote(void); */ void cat1_api_add_cat1_vote(void); + +/** + * @brief 用户实现,在cat1应用执行前,添加投票 +*/ +void cat1_api_add_cat1_app_vote(void); + +/** + * @brief 用户实现,在cat1应用执行完毕后,取消投票 +*/ +void cat1_api_remove_cat1_app_vote(void); + + /** * @brief 用户自行实现,电话开始时切换语音通路 * @return 0 success diff --git a/code/sdk/zhihui/4gTest/cat1_porting.c b/code/sdk/zhihui/4gTest/cat1_porting.c index 37ce8d182..07fcafdd1 100644 --- a/code/sdk/zhihui/4gTest/cat1_porting.c +++ b/code/sdk/zhihui/4gTest/cat1_porting.c @@ -80,7 +80,7 @@ static time_ctl_funcs_t g_cat1_time_ctl_funcs={ void cat1_api_remove_cat1_vote(void) { uint8_t cnt = pm_veto_get_id_cnt(PM_ID_CAT1); - if (cnt == 1) { + if (cnt > 0) { uapi_pm_remove_sleep_veto(PM_ID_CAT1); } else { // cat1_print_dbg("CAT1 SERVICE MCU has delete pm_id_cat1 vote\r\n"); @@ -98,6 +98,32 @@ void cat1_api_add_cat1_vote(void) cat1_print_dbg("\r\nCAT1 SERVICE MCU WAKEUP SUCCESS\r\n"); } +/** + * @brief 用户实现,在cat1应用执行前,添加投票 +*/ +void cat1_api_add_cat1_app_vote(void) +{ + uint8_t cnt = pm_veto_get_id_cnt(PM_ID_CAT1_APP); + if (cnt == 0) { + uapi_pm_add_sleep_veto(PM_ID_CAT1_APP); + } else { + // cat1_print_dbg("CAT1 SERVICE MCU has got pm_id_cat1_app vote\r\n"); + } +} + +/** + * @brief 用户实现,在cat1应用执行完毕后,取消投票 +*/ +void cat1_api_remove_cat1_app_vote(void) +{ + uint8_t cnt = pm_veto_get_id_cnt(PM_ID_CAT1_APP); + if (cnt > 0) { + uapi_pm_remove_sleep_veto(PM_ID_CAT1_APP); + } else { + // cat1_print_dbg("CAT1 SERVICE MCU has delete pm_id_cat1_app vote\r\n"); + } +} + static uint8_t cat1_voice=0; uint8_t cat1_api_get_cat1_volte_voice_state(void) @@ -359,7 +385,7 @@ errcode_t cat1_api_porting_init(void) S_MGPIO22,//ring_pin 0, S_MGPIO21,//wakemodem_pin - 0, + 1, #else PIN_NONE, //bat_pin 1, diff --git a/code/sdk/zhihui/leiniao/imsl_ln/CMakeLists.txt b/code/sdk/zhihui/leiniao/imsl_ln/CMakeLists.txt index 2db97e411..cdf3820da 100644 --- a/code/sdk/zhihui/leiniao/imsl_ln/CMakeLists.txt +++ b/code/sdk/zhihui/leiniao/imsl_ln/CMakeLists.txt @@ -21,6 +21,9 @@ set(SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/ln_api_emoji.c ${CMAKE_CURRENT_SOURCE_DIR}/ln_api_timeline_activities.c ${CMAKE_CURRENT_SOURCE_DIR}/ln_api_web_ack.c + ${CMAKE_CURRENT_SOURCE_DIR}/ln_http_client.c + ${CMAKE_CURRENT_SOURCE_DIR}/ln_http_download_client.c + ${CMAKE_CURRENT_SOURCE_DIR}/ln_file_write_queue.c ) # 公共头文件路径(供其他模块引用) diff --git a/code/sdk/zhihui/leiniao/imsl_ln/HTTP_CLIENT_USAGE.md b/code/sdk/zhihui/leiniao/imsl_ln/HTTP_CLIENT_USAGE.md new file mode 100644 index 000000000..407c6d657 --- /dev/null +++ b/code/sdk/zhihui/leiniao/imsl_ln/HTTP_CLIENT_USAGE.md @@ -0,0 +1,867 @@ +# HTTP客户端接口使用说明 + +本文档说明如何使用统一HTTP客户端接口 `ln_http_client.h` 和流式下载接口 `ln_http_download_client.h`。 + +## 目录 + +1. [接口概述](#接口概述) +2. [ln_http_client - 一次性HTTP请求](#ln_http_client---一次性http请求) +3. [ln_http_download_client - 流式下载](#ln_http_download_client---流式下载) +4. [使用场景对比](#使用场景对比) +5. [注意事项](#注意事项) + +--- + +## 接口概述 + +### ln_http_client +**用途**:一次性HTTP请求,适合小文件、API响应等场景 +**特点**: +- 一次性接收完整响应到内存缓冲区 +- 响应数据通过回调函数处理 +- 自动管理CAT1保活 +- 自动处理资源清理 +- **不支持SSE流**(仅支持普通HTTP响应) + +### ln_http_download_client +**用途**:流式HTTP下载,适合大文件、实时流等场景 +**特点**: +- 分块流式接收数据 +- 通过数据块回调实时处理数据 +- 支持进度上报 +- 支持断点续传(Range头) +- 自动管理CAT1保活 +- **同时支持普通HTTP流和SSE流**: + - 普通HTTP流:不添加SSE header,`enable_chunked = false` + - SSE流:添加 `Accept: text/event-stream` header,`enable_chunked = true` + +--- + +## ln_http_client - 一次性HTTP请求 + +### 基本使用流程 + +1. 定义回调函数(Header构建、Body构建、响应处理) +2. 配置请求参数 +3. 调用 `ln_http_client_request()` + +### 示例1:GET请求(简单API调用) + +```c +#include "ln_http_client.h" +#include "ln_api.h" + +/* 响应处理回调 */ +static uint32_t handle_get_response(const char *response_data, int response_len, + int status_code, void *user_data) +{ + if (status_code != 200) { + printf("HTTP request failed with status %d\n", status_code); + return ERRCODE_FAIL; + } + + // 处理响应数据 + if (response_data && response_len > 0) { + printf("Response: %.*s\n", response_len, response_data); + // 解析JSON或其他处理... + } + + return ERRCODE_SUCC; +} + +uint32_t get_device_info(void) +{ + const char *device_id = uapi_ln_get_device_id(); + const char *device_token = uapi_ln_get_device_token(); + + // 使用默认header(deviceId + deviceToken) + ln_http_request_t req = { + .url = "https://api.example.com/device/info", + .method = LN_HTTP_METHOD_GET, + .is_https = true, + .response_handler_cb = handle_get_response, + .user_data = NULL, + .enable_cat1_keepalive = true // 默认值,可省略 + }; + + return ln_http_client_request(&req); +} +``` + +### 示例2:POST请求(自定义Header和Body) + +```c +#include "ln_http_client.h" +#include "ln_api.h" +#include +#include + +/* Header构建上下文 */ +typedef struct { + const char *device_id; + const char *device_token; +} my_header_ctx_t; + +/* Body构建上下文 */ +typedef struct { + const char *json_data; +} my_body_ctx_t; + +/* Header构建回调 */ +static char* build_custom_header(void *user_data) +{ + my_header_ctx_t *ctx = (my_header_ctx_t*)user_data; + + // 使用默认header并追加自定义字段 + char *base_header = ln_http_build_default_header(ctx->device_id, ctx->device_token, NULL); + if (!base_header) { + return NULL; + } + + // 追加自定义header + size_t base_len = strlen(base_header); + size_t extra_len = strlen("Content-Type: application/json\r\n"); + char *full_header = (char *)realloc(base_header, base_len + extra_len + 1); + if (!full_header) { + free(base_header); + return NULL; + } + + strcat(full_header, "Content-Type: application/json\r\n"); + return full_header; +} + +/* Body构建回调 */ +static char* build_json_body(void *user_data, int *body_len_out, + char *content_type_out, int content_type_size) +{ + my_body_ctx_t *ctx = (my_body_ctx_t*)user_data; + + if (content_type_out && content_type_size > 0) { + snprintf(content_type_out, content_type_size, "application/json"); + } + + // 分配并返回body字符串(统一接口会负责释放) + if (ctx->json_data) { + int len = strlen(ctx->json_data); + char *body = (char *)malloc(len + 1); + if (body) { + strcpy(body, ctx->json_data); + if (body_len_out) { + *body_len_out = len; + } + } + return body; + } + + return NULL; +} + +/* 响应处理回调 */ +static uint32_t handle_post_response(const char *response_data, int response_len, + int status_code, void *user_data) +{ + if (status_code != 200) { + printf("POST failed with status %d\n", status_code); + return ERRCODE_FAIL; + } + + // 处理响应... + return ERRCODE_SUCC; +} + +/* 错误处理回调 */ +static void handle_error(int error_code, const char *error_msg, void *user_data) +{ + printf("HTTP error %d: %s\n", error_code, error_msg); +} + +uint32_t send_device_update(const char *json_data) +{ + const char *device_id = uapi_ln_get_device_id(); + const char *device_token = uapi_ln_get_device_token(); + + my_header_ctx_t header_ctx = { + .device_id = device_id, + .device_token = device_token + }; + + my_body_ctx_t body_ctx = { + .json_data = json_data + }; + + ln_http_request_t req = { + .url = "https://api.example.com/device/update", + .method = LN_HTTP_METHOD_POST, + .is_https = true, + .header_size = 2048, // 可选,默认2048 + .response_size = 8192, // 可选,默认8192 + .build_header_cb = build_custom_header, + .build_body_cb = build_json_body, + .response_handler_cb = handle_post_response, + .error_handler_cb = handle_error, // 可选 + .user_data = NULL, + .enable_cat1_keepalive = true + }; + + // 注意:需要传递user_data到回调 + // 可以通过在req中设置user_data,然后在回调中访问 + // 或者使用全局变量/上下文结构体 + + return ln_http_client_request(&req); +} +``` + +### 示例3:简单POST请求(空JSON对象) + +```c +#include "ln_http_client.h" +#include "ln_api.h" +#include +#include + +/* Header构建回调 */ +static char* build_simple_header(void *user_data) +{ + const char *device_id = uapi_ln_get_device_id(); + const char *device_token = uapi_ln_get_device_token(); + return ln_http_build_default_header(device_id, device_token, NULL); +} + +/* Body构建回调(返回空JSON对象) */ +static char* build_empty_json_body(void *user_data, int *body_len_out, + char *content_type_out, int content_type_size) +{ + if (content_type_out && content_type_size > 0) { + snprintf(content_type_out, content_type_size, "application/json"); + } + + // 分配动态字符串,统一接口会负责释放 + char *body = (char *)malloc(3); + if (body) { + strcpy(body, "{}"); + if (body_len_out) { + *body_len_out = 2; + } + } + return body; +} + +/* 响应处理回调 */ +static uint32_t handle_response(const char *response_data, int response_len, + int status_code, void *user_data) +{ + return (status_code == 200) ? ERRCODE_SUCC : ERRCODE_FAIL; +} + +uint32_t send_simple_post(void) +{ + ln_http_request_t req = { + .url = "https://api.example.com/endpoint", + .method = LN_HTTP_METHOD_POST, + .is_https = true, + .build_header_cb = build_simple_header, + .build_body_cb = build_empty_json_body, + .response_handler_cb = handle_response, + .enable_cat1_keepalive = true + }; + + return ln_http_client_request(&req); +} +``` + +### 参数说明 + +#### ln_http_request_t 结构体 + +| 字段 | 类型 | 必需 | 说明 | +|------|------|------|------| +| `url` | `const char*` | 是 | 请求URL | +| `method` | `ln_http_method_t` | 是 | HTTP方法(GET/POST/PUT/DELETE/HEAD) | +| `is_https` | `bool` | 是 | 是否HTTPS(true=443, false=80) | +| `port` | `uint16_t` | 否 | 自定义端口号(默认根据is_https决定) | +| `timeout_ms` | `uint32_t` | 否 | 超时时间(毫秒,0=默认值) | +| `header_size` | `int` | 否 | Header缓冲区大小(0=默认2048) | +| `response_size` | `int` | 否 | 响应缓冲区大小(0=默认8192) | +| `build_header_cb` | 回调函数 | 否 | Header构建回调(NULL=使用默认header) | +| `build_body_cb` | 回调函数 | 否 | Body构建回调(POST/PUT需要) | +| `response_handler_cb` | 回调函数 | **是** | 响应处理回调 | +| `error_handler_cb` | 回调函数 | 否 | 错误处理回调 | +| `user_data` | `void*` | 否 | 传递给回调的用户数据 | +| `enable_cat1_keepalive` | `bool` | 否 | 是否启用CAT1保活(默认true) | + +#### 回调函数说明 + +**Header构建回调**: +```c +char* build_header_cb(void *user_data); +``` +- 返回:分配的header字符串指针(统一接口会释放) +- 失败:返回NULL + +**Body构建回调**: +```c +char* build_body_cb(void *user_data, int *body_len_out, + char *content_type_out, int content_type_size); +``` +- `body_len_out`:输出参数,设置body长度 +- `content_type_out`:输出参数,设置Content-Type(如"application/json") +- 返回:分配的body字符串指针(统一接口会释放) +- 失败:返回NULL + +**响应处理回调**: +```c +uint32_t response_handler_cb(const char *response_data, int response_len, + int status_code, void *user_data); +``` +- `response_data`:响应数据(可能为NULL) +- `response_len`:响应数据长度 +- `status_code`:HTTP状态码 +- 返回:`ERRCODE_SUCC`表示成功,`ERRCODE_FAIL`表示失败 + +**错误处理回调**: +```c +void error_handler_cb(int error_code, const char *error_msg, void *user_data); +``` + +--- + +## ln_http_download_client - 流式下载 + +### 基本使用流程 + +1. 定义回调函数(Header构建、Body构建、数据块处理、进度回调) +2. 配置请求参数 +3. 调用 `ln_http_download_stream()` + +### 示例1:流式下载到文件(GET请求) + +```c +#include "ln_http_download_client.h" +#include "ln_api.h" +#include + +/* 数据块处理上下文 */ +typedef struct { + FILE *file; + size_t total_written; +} download_ctx_t; + +/* Header构建回调 */ +static char* build_download_header(void *user_data) +{ + const char *device_id = uapi_ln_get_device_id(); + const char *device_token = uapi_ln_get_device_token(); + return ln_http_build_default_header(device_id, device_token, NULL); +} + +/* 数据块处理回调 */ +static uint32_t handle_download_chunk(const char *data, int len, void *user_data) +{ + download_ctx_t *ctx = (download_ctx_t*)user_data; + + if (!ctx || !ctx->file || !data || len <= 0) { + return ERRCODE_FAIL; + } + + size_t written = fwrite(data, 1, (size_t)len, ctx->file); + if (written != (size_t)len) { + printf("Write failed: written=%zu, expected=%d\n", written, len); + return ERRCODE_FAIL; + } + + ctx->total_written += written; + return ERRCODE_SUCC; // 返回ERRCODE_SUCC继续下载 +} + +/* 进度回调(可选) */ +static void handle_download_progress(size_t downloaded, size_t total, void *user_data) +{ + if (total > 0) { + int percent = (int)((downloaded * 100) / total); + printf("Download progress: %zu/%zu (%d%%)\n", downloaded, total, percent); + } else { + printf("Download progress: %zu bytes\n", downloaded); + } +} + +uint32_t download_file(const char *url, const char *save_path) +{ + FILE *fd = fopen(save_path, "wb+"); + if (!fd) { + printf("Failed to open file: %s\n", save_path); + return ERRCODE_FAIL; + } + + download_ctx_t ctx = { + .file = fd, + .total_written = 0 + }; + + ln_http_download_request_t req = { + .url = url, + .method = LN_DOWNLOAD_METHOD_GET, + .is_https = true, + .header_size = 2048, + .response_size = 8192, + .build_header_cb = build_download_header, + .header_user_data = NULL, + .chunk_handler_cb = handle_download_chunk, + .progress_cb = handle_download_progress, // 可选 + .user_data = &ctx, + .enable_cat1_keepalive = true, + .enable_chunked = false, // 根据实际情况设置 + .range_header = NULL // 不使用断点续传 + }; + + uint32_t result = ln_http_download_stream(&req); + fclose(fd); + + if (result == ERRCODE_SUCC) { + printf("Download completed: %zu bytes\n", ctx.total_written); + } + + return result; +} +``` + +### 示例2:流式下载(POST请求 + SSE流) + +```c +#include "ln_http_download_client.h" +#include "ln_api.h" +#include +#include +#include + +/* Header构建上下文 */ +typedef struct { + const char *device_id; + const char *device_token; +} sse_header_ctx_t; + +/* Body构建上下文 */ +typedef struct { + char *body; + int body_len; + const char *content_type; +} sse_body_ctx_t; + +/* 数据块处理上下文 */ +typedef struct { + FILE *file; + size_t total_written; +} sse_chunk_ctx_t; + +/* Header构建回调(追加SSE相关header) */ +static char* build_sse_header(void *user_data) +{ + sse_header_ctx_t *ctx = (sse_header_ctx_t*)user_data; + char *base_header = ln_http_build_default_header(ctx->device_id, ctx->device_token, NULL); + if (!base_header) { + return NULL; + } + + // 追加SSE相关header + size_t base_len = strlen(base_header); + size_t extra_len = strlen("Accept: text/event-stream\r\nCache-Control: no-cache\r\n"); + char *full_header = (char *)realloc(base_header, base_len + extra_len + 1); + if (!full_header) { + free(base_header); + return NULL; + } + + strcat(full_header, "Accept: text/event-stream\r\n"); + strcat(full_header, "Cache-Control: no-cache\r\n"); + return full_header; +} + +/* Body构建回调 */ +static char* build_sse_body(void *user_data, int *body_len_out, + char *content_type_out, int content_type_size) +{ + sse_body_ctx_t *ctx = (sse_body_ctx_t*)user_data; + + if (content_type_out && content_type_size > 0 && ctx->content_type) { + snprintf(content_type_out, content_type_size, "%s", ctx->content_type); + } + + if (body_len_out) { + *body_len_out = ctx->body_len; + } + + return ctx->body; // 统一接口会负责释放 +} + +/* 数据块处理回调 */ +static uint32_t handle_sse_chunk(const char *data, int len, void *user_data) +{ + sse_chunk_ctx_t *ctx = (sse_chunk_ctx_t*)user_data; + + size_t written = fwrite(data, 1, (size_t)len, ctx->file); + if (written != (size_t)len) { + return ERRCODE_FAIL; + } + + ctx->total_written += written; + return ERRCODE_SUCC; +} + +uint32_t download_sse_stream(const char *url, const char *save_path, + const char *post_body, int post_body_len) +{ + FILE *fd = fopen(save_path, "w+"); + if (!fd) { + return ERRCODE_FAIL; + } + + // 构建multipart body(示例) + char *body = malloc(post_body_len); + memcpy(body, post_body, post_body_len); + + sse_header_ctx_t header_ctx = { + .device_id = uapi_ln_get_device_id(), + .device_token = uapi_ln_get_device_token() + }; + + sse_body_ctx_t body_ctx = { + .body = body, + .body_len = post_body_len, + .content_type = "multipart/form-data; boundary=----LNBOUNDARY" + }; + + sse_chunk_ctx_t chunk_ctx = { + .file = fd, + .total_written = 0 + }; + + ln_http_download_request_t req = { + .url = url, + .method = LN_DOWNLOAD_METHOD_POST, + .is_https = true, + .header_size = 2048, + .response_size = 8192, + .build_header_cb = build_sse_header, + .header_user_data = &header_ctx, + .build_body_cb = build_sse_body, + .body_user_data = &body_ctx, + .chunk_handler_cb = handle_sse_chunk, + .user_data = &chunk_ctx, + .enable_cat1_keepalive = true, + .enable_chunked = true, // SSE通常使用chunked传输 + .range_header = NULL + }; + + uint32_t result = ln_http_download_stream(&req); + fclose(fd); + + return result; +} +``` + +### 示例3:断点续传下载 + +```c +#include "ln_http_download_client.h" +#include +#include + +/* 数据块处理上下文 */ +typedef struct { + FILE *file; + size_t total_written; + long long resume_offset; +} resume_ctx_t; + +/* Header构建回调(追加Range头) */ +static char* build_resume_header(void *user_data) +{ + resume_ctx_t *ctx = (resume_ctx_t*)user_data; + const char *device_id = uapi_ln_get_device_id(); + const char *device_token = uapi_ln_get_device_token(); + + char *base_header = ln_http_build_default_header(device_id, device_token, NULL); + if (!base_header) { + return NULL; + } + + // 追加Range头 + char range_str[64]; + snprintf(range_str, sizeof(range_str), "Range: bytes=%lld-\r\n", ctx->resume_offset); + + size_t base_len = strlen(base_header); + size_t range_len = strlen(range_str); + char *full_header = (char *)realloc(base_header, base_len + range_len + 1); + if (!full_header) { + free(base_header); + return NULL; + } + + strcat(full_header, range_str); + return full_header; +} + +/* 数据块处理回调 */ +static uint32_t handle_resume_chunk(const char *data, int len, void *user_data) +{ + resume_ctx_t *ctx = (resume_ctx_t*)user_data; + + size_t written = fwrite(data, 1, (size_t)len, ctx->file); + if (written != (size_t)len) { + return ERRCODE_FAIL; + } + + ctx->total_written += written; + return ERRCODE_SUCC; +} + +uint32_t download_with_resume(const char *url, const char *save_path) +{ + // 检查文件是否已存在,计算续传偏移 + long long resume_offset = 0; + FILE *fexist = fopen(save_path, "rb"); + if (fexist) { + fseek(fexist, 0, SEEK_END); + resume_offset = ftell(fexist); + fclose(fexist); + } + + // 打开文件(续传用ab+,全量用wb+) + FILE *fd = fopen(save_path, resume_offset > 0 ? "ab+" : "wb+"); + if (!fd) { + return ERRCODE_FAIL; + } + + resume_ctx_t ctx = { + .file = fd, + .total_written = 0, + .resume_offset = resume_offset + }; + + ln_http_download_request_t req = { + .url = url, + .method = LN_DOWNLOAD_METHOD_GET, + .is_https = true, + .build_header_cb = build_resume_header, + .header_user_data = &ctx, + .chunk_handler_cb = handle_resume_chunk, + .user_data = &ctx, + .enable_cat1_keepalive = true, + .enable_chunked = false, + .range_header = NULL // Range头在header回调中构建 + }; + + uint32_t result = ln_http_download_stream(&req); + fclose(fd); + + if (result == ERRCODE_SUCC && resume_offset > 0) { + printf("Resume download completed: %lld + %zu bytes\n", + resume_offset, ctx.total_written); + } + + return result; +} +``` + +### 参数说明 + +#### ln_http_download_request_t 结构体 + +| 字段 | 类型 | 必需 | 说明 | +|------|------|------|------| +| `url` | `const char*` | 是 | 请求URL | +| `method` | `ln_download_method_t` | 是 | HTTP方法(GET/POST) | +| `is_https` | `bool` | 是 | 是否HTTPS(true=443, false=80) | +| `port` | `uint16_t` | 否 | 自定义端口号 | +| `header_size` | `int` | 否 | Header缓冲区大小(0=默认2048) | +| `response_size` | `int` | 否 | 响应缓冲区大小(0=默认8192) | +| `build_header_cb` | 回调函数 | 否 | Header构建回调(NULL=使用默认header) | +| `header_user_data` | `void*` | 否 | Header构建回调的用户数据 | +| `build_body_cb` | 回调函数 | 否 | Body构建回调(POST需要) | +| `body_user_data` | `void*` | 否 | Body构建回调的用户数据 | +| `chunk_handler_cb` | 回调函数 | **是** | 数据块处理回调 | +| `progress_cb` | 回调函数 | 否 | 进度回调 | +| `error_handler_cb` | 回调函数 | 否 | 错误处理回调 | +| `user_data` | `void*` | 否 | 传递给chunk_handler_cb的用户数据 | +| `enable_cat1_keepalive` | `bool` | 否 | 是否启用CAT1保活(默认true) | +| `enable_chunked` | `bool` | 否 | 是否启用分块传输(默认false) | +| `range_header` | `const char*` | 否 | Range头(如"bytes=1024-"),NULL=不使用 | + +#### 回调函数说明 + +**数据块处理回调**: +```c +uint32_t chunk_handler_cb(const char *data, int len, void *user_data); +``` +- `data`:接收到的数据块 +- `len`:数据块长度 +- 返回:`ERRCODE_SUCC`继续下载,`ERRCODE_FAIL`中止下载 + +**进度回调**: +```c +void progress_cb(size_t downloaded, size_t total, void *user_data); +``` +- `downloaded`:已下载字节数 +- `total`:总字节数(如果未知则为0) + +**错误处理回调**: +```c +void error_handler_cb(int error_code, const char *error_msg, void *user_data); +``` + +--- + +## 使用场景对比 + +| 场景 | 使用接口 | 说明 | +|------|----------|------| +| 获取设备信息 | `ln_http_client` | 小JSON响应,一次性接收 | +| 提交用户数据 | `ln_http_client` | POST请求,响应较小 | +| 下载大文件(>1MB) | `ln_http_download_client` | 需要流式接收,节省内存 | +| **普通HTTP流** | `ln_http_download_client` | 普通HTTP流式响应(非SSE) | +| **SSE流式数据** | `ln_http_download_client` | Server-Sent Events流,需要添加SSE header | +| 断点续传 | `ln_http_download_client` | 支持Range头 | +| 文件上传 | `ln_http_client` | 通常响应较小 | + +### SSE vs 普通HTTP流 + +**普通HTTP流**: +- 服务端返回普通HTTP响应,使用分块传输(chunked)或固定长度 +- 客户端设置:`enable_chunked = false`(由服务端决定) +- 不添加SSE相关header +- 适用于普通文件下载、大文件传输 + +**SSE流(Server-Sent Events)**: +- 服务端返回SSE格式的流式数据 +- 客户端设置: + - Header中添加:`Accept: text/event-stream` + - `enable_chunked = true` +- 适用于实时事件推送、服务器主动推送数据 + +--- + +## 注意事项 + +### 1. 内存管理 + +- **Header/Body构建回调**:返回的字符串指针必须是通过`malloc`分配的,统一接口会负责释放 +- **不要返回静态字符串**:不要在回调中返回字符串字面量,必须动态分配 +- **示例(错误)**: +```c +// ❌ 错误:返回静态字符串 +static char* build_body(void *user_data, ...) { + return "{}"; // 统一接口会尝试free,导致崩溃 +} + +// ✅ 正确:动态分配 +static char* build_body(void *user_data, ...) { + char *body = (char *)malloc(3); + if (body) { + strcpy(body, "{}"); + } + return body; +} +``` + +### 2. CAT1保活 + +- 默认启用CAT1保活(`enable_cat1_keepalive = true`) +- 保活在请求开始前启用,请求结束后(成功或失败)自动释放 +- 如果手动管理CAT1保活,可以设置`enable_cat1_keepalive = false` + +### 3. 错误处理 + +- 统一接口会自动处理连接、发送、接收等错误 +- 错误通过`error_handler_cb`回调通知 +- 如果没有设置错误回调,错误会静默失败 + +### 4. 流式下载中断 + +- 如果数据块处理回调返回`ERRCODE_FAIL`,下载会立即中止 +- 已下载的数据仍然有效(例如已写入文件的部分) + +### 5. 线程安全 + +- 接口本身不保证线程安全 +- 如果多线程调用,需要外部加锁保护 + +### 6. 超时处理 + +- `ln_http_client`支持`timeout_ms`参数 +- `ln_http_download_client`目前不支持超时参数(使用底层默认超时) + +### 7. 响应大小限制 + +- `ln_http_client`:响应大小受`response_size`限制(默认8192字节) +- `ln_http_download_client`:理论上无限制(流式处理) + +### 8. Header构建工具函数 + +提供了两个便捷函数: +- `ln_http_build_default_header()`:构建默认header(deviceId + deviceToken) +- `ln_http_build_device_header()`:构建带设备信息的header(deviceId + deviceToken + deviceModel + deviceVersion) + +--- + +## 完整示例参考 + +实际代码中的使用示例: +- `ln_api_story_exit.c`:简单POST请求示例 +- `ln_api_device_info.c`:GET请求示例 +- `ln_api_story_choose.c`:流式下载(POST + multipart)示例 +- `ln_api_ota.c`:断点续传下载示例 + +--- + +## 常见问题 + +### Q1: 为什么需要分开两个接口? +A: `ln_http_client`适合一次性接收完整响应,`ln_http_download_client`适合流式处理大文件,两者使用场景不同。 + +### Q2: 如何判断应该使用哪个接口? +A: 如果响应数据较小(<8KB),使用`ln_http_client`;如果响应较大或需要实时处理,使用`ln_http_download_client`。 + +### Q3: 流式下载能否用于小文件? +A: 可以,但没必要。小文件使用`ln_http_client`更简单。 + +### Q4: 如何实现断点续传? +A: 在Header构建回调中追加`Range: bytes=偏移量-`头,然后使用`ab+`模式打开文件追加写入。 + +### Q5: 回调函数中如何传递多个参数? +A: 定义一个上下文结构体,包含所有需要的参数,然后通过`user_data`传递。 + +### Q6: `ln_http_client` 支持SSE吗? +A: **不支持**。`ln_http_client` 是一次性接收完整响应,不适合SSE流。SSE需要使用 `ln_http_download_client`。 + +### Q7: `ln_http_download_client` 如何区分普通HTTP流和SSE流? +A: +- **普通HTTP流**:不添加SSE header,`enable_chunked = false`(默认值) +- **SSE流**:在Header构建回调中添加 `Accept: text/event-stream`,设置 `enable_chunked = true` + +示例: +```c +// SSE流配置 +ln_http_download_request_t req = { + .url = url, + .method = LN_DOWNLOAD_METHOD_POST, + .build_header_cb = build_sse_header, // 内部添加 Accept: text/event-stream + .enable_chunked = true, // SSE需要chunked传输 + // ... +}; + +// 普通HTTP流配置 +ln_http_download_request_t req = { + .url = url, + .method = LN_DOWNLOAD_METHOD_GET, + .build_header_cb = build_normal_header, // 不添加SSE header + .enable_chunked = false, // 或不设置(默认false) + // ... +}; +``` + +--- + +## 更新日志 + +- 2025-01-XX:初始版本,支持基本HTTP请求和流式下载 + diff --git a/code/sdk/zhihui/leiniao/imsl_ln/ln_api.c b/code/sdk/zhihui/leiniao/imsl_ln/ln_api.c index 23ad08dad..741a8c7f5 100644 --- a/code/sdk/zhihui/leiniao/imsl_ln/ln_api.c +++ b/code/sdk/zhihui/leiniao/imsl_ln/ln_api.c @@ -1,6 +1,10 @@ #include "ln_api.h" /* for https/http client */ #include "netstack/http/include/httpclient.h" +/* for async file write queue */ +#if LN_HTTP_DOWNLOAD_USE_QUEUE +#include "ln_file_write_queue.h" +#endif /* for HMAC-SHA256 */ #include "mbedtls/md.h" /* for MD5 file verify */ @@ -13,6 +17,13 @@ #include "stdio.h" #include "custom_utils.h" #include "ai_media.h" +#if !LN_HTTP_DOWNLOAD_USE_QUEUE +#include "watchdog.h" /* 直接写文件模式需要看门狗喂狗 */ +#endif +/* 使用extern声明,避免依赖具体实现(PPP或cat1Service) */ +#if defined(SUPPORT_CAT1_SERVICE) || defined(SUPPORT_PPP_SERVICE) +extern void cat1_api_keep_wakeup(uint8_t keep_wakeup); +#endif /* for DNS resolution */ #include "lwip/netdb.h" #include "lwip/sockets.h" @@ -24,7 +35,7 @@ static app_task_definition_t ln_send_taskcfg = {0}; static unsigned long g_ln_send_queue = 0xFFFFFFFF; -#define LN_HTTP_BOARD_TASK_SIZE 0x2500 +#define LN_HTTP_BOARD_TASK_SIZE 0x5000 static char *s_cached_device_id = NULL; char *g_device_token = NULL; // 设备token,服务器获取 @@ -461,6 +472,10 @@ int uapi_ln_download_file(const char *url, const char *save_path) WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD] 开始下载: %s -> %s", url, save_path); g_ln_is_file_downloading = 1; +#if defined(SUPPORT_CAT1_SERVICE) || defined(SUPPORT_PPP_SERVICE) + /* 保持CAT1唤醒,防止下载过程中休眠 */ + cat1_api_keep_wakeup(1); +#endif HttpClient client = {0}; HttpClientData client_data = {0}; @@ -474,6 +489,12 @@ int uapi_ln_download_file(const char *url, const char *save_path) g_ln_is_file_downloading = 0; return ERRCODE_FAIL; } + + /* 优化文件写入:设置更大的写入缓冲区(64KB),减少fwrite调用开销 */ + if (setvbuf(fd, NULL, _IOFBF, 64 * 1024) != 0) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD] setvbuf failed, using default buffer"); + } HTTPC_RESULT prep = ln_http_prepare_auto(&client_data, 2048, LN_CLIENT_PREPARE_SIZE * 2); if (prep != HTTP_SUCCESS) @@ -567,6 +588,12 @@ int uapi_ln_download_file(const char *url, const char *save_path) HttpClientClse(&client); fclose(fd); g_ln_is_file_downloading = 0; + +#if defined(SUPPORT_CAT1_SERVICE) || defined(SUPPORT_PPP_SERVICE) + /* 释放CAT1唤醒,允许休眠 */ + cat1_api_keep_wakeup(0); +#endif + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD] 下载过程结束,ret=%d", ret); return ret; } @@ -580,7 +607,7 @@ int uapi_ln_download_with_retry(const char *url, const char *save_path, int max_ return ERRCODE_FAIL; } WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD] 开始下载: %s -> %s", url, save_path); - uapi_pm_add_sleep_veto(PM_ID_DEBUG); + cat1_api_remove_cat1_app_vote(); int ret = uapi_ln_download_file(url, save_path); if (ERRCODE_SUCC != ret) { @@ -595,7 +622,7 @@ int uapi_ln_download_with_retry(const char *url, const char *save_path, int max_ } } } - uapi_pm_remove_sleep_veto(PM_ID_DEBUG); + cat1_api_remove_cat1_app_vote(); return ret; } @@ -612,6 +639,23 @@ int uapi_ln_download_file_resume(const char *url, const char *save_path) return ERRCODE_FAIL; } +#if LN_HTTP_DOWNLOAD_USE_QUEUE + /* 初始化异步文件写入队列(如果未初始化) */ + static int queue_initialized = 0; + if (!queue_initialized) { + if (ln_file_write_queue_init() != ERRCODE_SUCC) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] Failed to init file write queue"); + return ERRCODE_FAIL; + } + queue_initialized = 1; + } +#endif + +#if defined(SUPPORT_CAT1_SERVICE) || defined(SUPPORT_PPP_SERVICE) + /* 保持CAT1唤醒,防止下载过程中休眠 */ + cat1_api_keep_wakeup(1); +#endif + long long resume_offset = 0; /* 判断是否存在部分文件,计算续传偏移 */ { @@ -632,25 +676,49 @@ int uapi_ln_download_file_resume(const char *url, const char *save_path) HttpClientData client_data = {0}; int ret = -1; size_t total_written = 0; - - if(resume_offset > 0) - { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] 断点续传,resume_offset=%lld", resume_offset); - } - /* 以追加模式打开(若服务端返回200将切换为覆盖写)*/ - FILE *fd = fopen(save_path, resume_offset > 0 ? "ab+" : "wb+"); +#if LN_HTTP_DOWNLOAD_USE_QUEUE + /* 文件句柄和写入上下文(用于异步写入) */ + FILE *fd = NULL; + ln_file_write_ctx_t write_ctx = {0}; + write_ctx.status = LN_FILE_WRITE_STATUS_PENDING; + write_ctx.error_code = ERRCODE_SUCC; + write_ctx.total_written = 0; + write_ctx.ref_count = 0; + + int packet_count = 0; /* 数据包计数 */ + int is_first_packet = 1; /* 是否为第一包 */ +#else + /* 直接写文件模式:打开文件 */ + const char *open_mode = resume_offset > 0 ? "ab+" : "wb+"; + FILE *fd = fopen(save_path, open_mode); if (!fd) { WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] fopen failed for %s", save_path); return ERRCODE_FAIL; } + + /* 优化文件写入:设置更大的写入缓冲区(64KB),减少fwrite调用开销 */ + if (setvbuf(fd, NULL, _IOFBF, 64 * 1024) != 0) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] setvbuf failed, using default buffer"); + } + + /* 如果续传,文件已打开在末尾位置,无需额外操作 */ +#endif + + if(resume_offset > 0) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] 断点续传,resume_offset=%lld", resume_offset); + } HTTPC_RESULT prep = ln_http_prepare_auto(&client_data, 2048, LN_CLIENT_PREPARE_SIZE * 2); if (prep != HTTP_SUCCESS) { WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] prepare failed: %d", prep); +#if !LN_HTTP_DOWNLOAD_USE_QUEUE fclose(fd); +#endif return ERRCODE_FAIL; } @@ -662,7 +730,9 @@ int uapi_ln_download_file_resume(const char *url, const char *save_path) if (!header_buf) { HttpClientUnprepare(&client_data); +#if !LN_HTTP_DOWNLOAD_USE_QUEUE fclose(fd); +#endif return ERRCODE_FAIL; } int hdr = snprintf(header_buf, 128, "Range: bytes=%lld-\r\n", resume_offset); @@ -670,7 +740,9 @@ int uapi_ln_download_file_resume(const char *url, const char *save_path) { free(header_buf); HttpClientUnprepare(&client_data); +#if !LN_HTTP_DOWNLOAD_USE_QUEUE fclose(fd); +#endif return ERRCODE_FAIL; } HttpClientSetCustomHeader(&client, header_buf); @@ -683,7 +755,9 @@ int uapi_ln_download_file_resume(const char *url, const char *save_path) { WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] connection failed, ret=0x%x", ret); if (header_buf) free(header_buf); +#if !LN_HTTP_DOWNLOAD_USE_QUEUE fclose(fd); +#endif HttpClientUnprepare(&client_data); return ERRCODE_FAIL; } @@ -693,7 +767,9 @@ int uapi_ln_download_file_resume(const char *url, const char *save_path) { WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] send request failed, ret=0x%x", ret); if (header_buf) free(header_buf); +#if !LN_HTTP_DOWNLOAD_USE_QUEUE fclose(fd); +#endif HttpClientClse(&client); HttpClientUnprepare(&client_data); return ERRCODE_FAIL; @@ -706,7 +782,9 @@ int uapi_ln_download_file_resume(const char *url, const char *save_path) { WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] first recv failed: %d", first_recv); if (header_buf) free(header_buf); +#if !LN_HTTP_DOWNLOAD_USE_QUEUE fclose(fd); +#endif HttpClientClse(&client); HttpClientUnprepare(&client_data); return ERRCODE_FAIL; @@ -717,25 +795,65 @@ int uapi_ln_download_file_resume(const char *url, const char *save_path) if (code == 200 && resume_offset > 0) { /* 服务端未按Range返回,改为覆盖写 */ + resume_offset = 0; +#if LN_HTTP_DOWNLOAD_USE_QUEUE + /* 重置写入上下文 */ + write_ctx.status = LN_FILE_WRITE_STATUS_PENDING; + write_ctx.total_written = 0; + write_ctx.ref_count = 0; + is_first_packet = 1; +#else + /* 重新打开文件为覆盖模式 */ fclose(fd); fd = fopen(save_path, "wb+"); if (!fd) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] fopen failed for %s (overwrite mode)", save_path); if (header_buf) free(header_buf); HttpClientClse(&client); HttpClientUnprepare(&client_data); return ERRCODE_FAIL; } - resume_offset = 0; + if (setvbuf(fd, NULL, _IOFBF, 64 * 1024) != 0) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] setvbuf failed, using default buffer"); + } +#endif } /* 写入首块内容(若有)*/ if (client_data.contentBlockLen > 0) { +#if LN_HTTP_DOWNLOAD_USE_QUEUE + const char *open_mode = resume_offset > 0 ? "ab+" : "wb+"; + errcode_t write_ret = ln_file_write_queue_add_task( + &fd, + &write_ctx, + save_path, /* 第一包需要文件路径 */ + open_mode, /* 第一包需要打开模式 */ + (const uint8_t *)client_data.responseBuf, + client_data.contentBlockLen, + 1, /* is_first_packet */ + 0 /* is_last_packet */ + ); + + if (write_ret != ERRCODE_SUCC) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] Failed to add first write task"); + if (header_buf) free(header_buf); + HttpClientClse(&client); + HttpClientUnprepare(&client_data); + return ERRCODE_FAIL; + } + + total_written += client_data.contentBlockLen; + packet_count++; + is_first_packet = 0; +#else + /* 直接写入文件 */ size_t written = fwrite(client_data.responseBuf, 1, client_data.contentBlockLen, fd); if (written != client_data.contentBlockLen) { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] write failed on first block, written=%zu, expected=%d", + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] write failed, written=%zu, expected=%d", written, client_data.contentBlockLen); if (header_buf) free(header_buf); fclose(fd); @@ -744,17 +862,80 @@ int uapi_ln_download_file_resume(const char *url, const char *save_path) return ERRCODE_FAIL; } total_written += written; +#endif } } /* 后续接收循环 */ +#if !LN_HTTP_DOWNLOAD_USE_QUEUE + /* 直接写文件模式:用于定期喂狗,防止长时间下载导致看门狗超时 */ + extern uint32_t uapi_tcxo_get_ms(void); + uint32_t last_watchdog_kick_time = uapi_tcxo_get_ms(); + const uint32_t WATCHDOG_KICK_INTERVAL_MS = 2000; /* 每2秒喂一次狗(看门狗超时8秒) */ +#endif + while (client_data.isMore) { +#if !LN_HTTP_DOWNLOAD_USE_QUEUE + /* 定期喂狗,防止长时间下载导致看门狗超时触发 NMI */ + uint32_t current_time = uapi_tcxo_get_ms(); + uint32_t time_since_last_kick = (current_time >= last_watchdog_kick_time) ? + (current_time - last_watchdog_kick_time) : + (0xFFFFFFFF - last_watchdog_kick_time + current_time + 1); + if (time_since_last_kick >= WATCHDOG_KICK_INTERVAL_MS) { + extern errcode_t uapi_watchdog_kick(void); + uapi_watchdog_kick(); + last_watchdog_kick_time = current_time; + } +#endif + HTTPC_RESULT recv_res = HttpClientRecvResponse(&client, &client_data); if (recv_res == HTTP_SUCCESS || recv_res == HTTP_EAGAIN) { if (client_data.contentBlockLen > 0) { +#if LN_HTTP_DOWNLOAD_USE_QUEUE + /* 判断是否为最后一包 */ + int is_last = (!client_data.isMore) ? 1 : 0; + + /* 使用异步写入队列 */ + errcode_t write_ret = ln_file_write_queue_add_task( + &fd, + &write_ctx, + NULL, /* 非第一包,不需要文件路径 */ + NULL, /* 非第一包,不需要打开模式 */ + (const uint8_t *)client_data.responseBuf, + client_data.contentBlockLen, + 0, /* is_first_packet */ + is_last /* is_last_packet */ + ); + + if (write_ret != ERRCODE_SUCC) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] Failed to add write task"); + if (header_buf) free(header_buf); + ln_file_write_queue_close_file(&fd, &write_ctx); + HttpClientClse(&client); + HttpClientUnprepare(&client_data); + return ERRCODE_FAIL; + } + + total_written += client_data.contentBlockLen; + packet_count++; + + /* 检查写入错误 */ + if (ln_file_write_queue_get_status(&write_ctx) == LN_FILE_WRITE_STATUS_ERROR) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] Write error detected"); + if (header_buf) free(header_buf); + ln_file_write_queue_close_file(&fd, &write_ctx); + HttpClientClse(&client); + HttpClientUnprepare(&client_data); + return ERRCODE_FAIL; + } + + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] write task added, total_written=%zu, packet=%d", + total_written, packet_count); +#else + /* 直接写入文件 */ size_t written = fwrite(client_data.responseBuf, 1, client_data.contentBlockLen, fd); if (written != client_data.contentBlockLen) { @@ -767,22 +948,56 @@ int uapi_ln_download_file_resume(const char *url, const char *save_path) return ERRCODE_FAIL; } total_written += written; - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] write first block success, written=%zu", total_written); +#endif } } else { WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] recv failed: %d", recv_res); + /* 网络异常,标记下载失败 */ break; } } int final_code = HttpClientGetResponseCode(&client); WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] final code=%d, total_written=%zu", final_code, total_written); - if ((final_code == 200 || final_code == 206) && total_written == (size_t)client_data.responseContentLen) + +#if LN_HTTP_DOWNLOAD_USE_QUEUE + /* 判断下载是否成功:只有HTTP状态码200/206且正常结束才等待文件写入完成 */ + int download_success = ((final_code == 200 || final_code == 206) && client_data.isMore == 0); + + if (download_success) { + /* 下载成功,等待所有写入任务完成 */ + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] Download successful, waiting for all write tasks to complete..."); + errcode_t wait_ret = ln_file_write_queue_wait_done(&write_ctx, 30000); /* 最多等待30秒 */ + if (wait_ret != ERRCODE_SUCC) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] Wait for write tasks timeout or error"); + } + } else { + /* 下载失败(网络异常等),不等待文件写入完成,直接关闭文件 */ + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] Download failed (code=%d, isMore=%d), skip waiting for write tasks", + final_code, client_data.isMore); + } + + /* 获取实际写入的字节数 */ + size_t actual_written = ln_file_write_queue_get_written(&write_ctx); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] Actual written: %zu bytes", actual_written); + + /* 安全关闭文件 */ + ln_file_write_queue_close_file(&fd, &write_ctx); +#else + /* 直接写文件模式:刷新缓冲区并关闭文件 */ + fflush(fd); + fclose(fd); + size_t actual_written = total_written; + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] Direct write mode, total_written=%zu bytes", actual_written); +#endif + + if ((final_code == 200 || final_code == 206) && actual_written > 0) { ret = ERRCODE_SUCC; - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] 下载成功 (%s)", resume_offset > 0 ? "续传" : "全量"); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD_RESUME] 下载成功 (%s), written=%zu", + resume_offset > 0 ? "续传" : "全量", actual_written); } else { @@ -793,7 +1008,12 @@ int uapi_ln_download_file_resume(const char *url, const char *save_path) if (header_buf) free(header_buf); HttpClientUnprepare(&client_data); HttpClientClse(&client); - fclose(fd); + +#if defined(SUPPORT_CAT1_SERVICE) || defined(SUPPORT_PPP_SERVICE) + /* 释放CAT1唤醒,允许休眠 */ + cat1_api_keep_wakeup(0); +#endif + return ret; } /* 断点续传下载函数封装:带重试,不做UI通知与资源释放 */ @@ -813,7 +1033,7 @@ int uapi_ln_download_file_resume_with_retry(const char *url, const char *save_pa g_ln_is_file_downloading = 1; //添加睡眠投票 - uapi_pm_add_sleep_veto(PM_ID_DEBUG); + cat1_api_add_cat1_app_vote(); int ret = uapi_ln_download_file_resume(url, save_path); if (ERRCODE_SUCC != ret) @@ -831,7 +1051,7 @@ int uapi_ln_download_file_resume_with_retry(const char *url, const char *save_pa } g_ln_is_file_downloading = 0; //移除睡眠投票 - uapi_pm_remove_sleep_veto(PM_ID_DEBUG); + cat1_api_remove_cat1_app_vote(); return ret; } /* 自适应申请HttpClient缓冲(保证header>=2048),失败则逐步扩容重试 */ @@ -1086,7 +1306,7 @@ static uint32_t ln_download_mp3_file_advanced(const char *audio_url, const char #ifdef SUPPORT_CAT1_SERVICE /* CAT1 网络保活处理 */ - cat1_api_add_cat1_vote(); + cat1_api_add_cat1_app_vote(); cat1_api_disable_cat1_cmd(0); LOS_Msleep(300); #endif @@ -1114,6 +1334,9 @@ static uint32_t ln_download_mp3_file_advanced(const char *audio_url, const char fclose(fd); #endif free(save_path); +#ifdef SUPPORT_CAT1_SERVICE + cat1_api_remove_cat1_app_vote(); +#endif return ERRCODE_FAIL; } @@ -1127,6 +1350,9 @@ static uint32_t ln_download_mp3_file_advanced(const char *audio_url, const char #endif HttpClientUnprepare(&client_data); free(save_path); +#ifdef SUPPORT_CAT1_SERVICE + cat1_api_remove_cat1_app_vote(); +#endif return ERRCODE_FAIL; } @@ -1141,6 +1367,9 @@ static uint32_t ln_download_mp3_file_advanced(const char *audio_url, const char HttpClientClse(&client); HttpClientUnprepare(&client_data); free(save_path); +#ifdef SUPPORT_CAT1_SERVICE + cat1_api_remove_cat1_app_vote(); +#endif return ERRCODE_FAIL; } @@ -1205,6 +1434,9 @@ static uint32_t ln_download_mp3_file_advanced(const char *audio_url, const char HttpClientUnprepare(&client_data); HttpClientClse(&client); free(save_path); +#ifdef SUPPORT_CAT1_SERVICE + cat1_api_remove_cat1_app_vote(); +#endif return ERRCODE_SUCC; } diff --git a/code/sdk/zhihui/leiniao/imsl_ln/ln_api.h b/code/sdk/zhihui/leiniao/imsl_ln/ln_api.h index 1d89c15b4..891c471de 100644 --- a/code/sdk/zhihui/leiniao/imsl_ln/ln_api.h +++ b/code/sdk/zhihui/leiniao/imsl_ln/ln_api.h @@ -82,6 +82,11 @@ typedef struct #define LN_CLIENT_PREPARE_SIZE 2 * 1024 #define TEST_MP3_DOWNLOAD 0 // 测试下载mp3 +/* HTTP下载文件写入方式选择:1=使用异步队列写入,0=直接写入文件 */ +#ifndef LN_HTTP_DOWNLOAD_USE_QUEUE +#define LN_HTTP_DOWNLOAD_USE_QUEUE 1 // 默认使用异步队列写入 +#endif + #define LN_HTTP_SERVICE_CMD_GET_DEVICE_TOKEN 0x1 /* 获取设备 token */ #define LN_HTTP_SERVICE_CMD_SPEECH_CHAT_STREAM 0x2 /* 语音对话流 */ #define LN_HTTP_SERVICE_CMD_SSE_RECV 0x3 /* 语音对话流分片接收 */ diff --git a/code/sdk/zhihui/leiniao/imsl_ln/ln_api_device_info.c b/code/sdk/zhihui/leiniao/imsl_ln/ln_api_device_info.c index f43bfb29b..d9767c60d 100644 --- a/code/sdk/zhihui/leiniao/imsl_ln/ln_api_device_info.c +++ b/code/sdk/zhihui/leiniao/imsl_ln/ln_api_device_info.c @@ -1,4 +1,5 @@ #include "ln_api.h" +#include "ln_http_client.h" #include #include #include @@ -6,6 +7,10 @@ #include #include "wearable_log.h" #include "custom_utils.h" +/* 使用extern声明,避免依赖具体实现(PPP或cat1Service) */ +#if defined(SUPPORT_CAT1_SERVICE) || defined(SUPPORT_PPP_SERVICE) +extern void cat1_api_keep_wakeup(uint8_t keep_wakeup); +#endif LnCharacterConfig g_ln_character_config = {0}; @@ -127,6 +132,12 @@ void ln_download_screen_image(void) uapi_delete_files(LN_DEVICE_SCREEN_IMAGE_FILE); WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[DEVICE_CHARACTER] 屏保下载URL: %s, 保存路径: %s", url, save_path); uapi_ln_set_file_download_type(LN_FILE_DOWNLOAD_TYPE_SCREEN_IMAGE); + +#if defined(SUPPORT_CAT1_SERVICE) || defined(SUPPORT_PPP_SERVICE) + /* 保持CAT1唤醒,防止下载过程中休眠 */ + cat1_api_keep_wakeup(1); +#endif + int ret = uapi_ln_download_file_resume_with_retry(url, save_path, 5); if (ret == 0) { @@ -140,6 +151,12 @@ void ln_download_screen_image(void) } WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DEVICE_CHARACTER] 屏保下载结束,ret=%d", ret); uapi_ln_set_file_download_type(LN_FILE_DOWNLOAD_TYPE_NONE); + +#if defined(SUPPORT_CAT1_SERVICE) || defined(SUPPORT_PPP_SERVICE) + /* 释放CAT1唤醒,允许休眠 */ + cat1_api_keep_wakeup(0); +#endif + /* 一次性使用后释放 */ free(g_ln_pending_screen_image_url); g_ln_pending_screen_image_url = NULL; @@ -465,264 +482,201 @@ void ln_parse_character_config(const char *json_buf, int json_len) } // 获取设备角色信息 -uint32_t ln_device_get_character_http(const char *device_id, - const char *device_token) +/* Header构建上下文 */ +typedef struct { + const char *device_id; + const char *device_token; +} device_header_ctx_t; + +/* Header构建回调 */ +static char* build_device_header(void *user_data) { - if (!device_id || !device_token) - return ERRCODE_FAIL; - -#ifdef SUPPORT_CAT1_SERVICE - /* CAT1 保活 */ - cat1_api_add_cat1_vote(); - cat1_api_disable_cat1_cmd(0); - LOS_Msleep(200); -#endif - - HttpClient client = (HttpClient){0}; - HttpClientData clientData = (HttpClientData){0}; - client.isHttp = false; - client.remotePort = 443; - - char *header_buf = (char *)malloc(512); - if (!header_buf) - return ERRCODE_FAIL; - int hdr = snprintf(header_buf, 512, - "deviceId: %s\r\n" - "deviceToken: %s\r\n" - "Content-Type: application/json\r\n", - device_id, device_token); - if (hdr <= 0) - { - free(header_buf); - return ERRCODE_FAIL; - } - HttpClientSetCustomHeader(&client, header_buf); - - printf("device getCharacter header %s\n", header_buf); + device_header_ctx_t *ctx = (device_header_ctx_t*)user_data; + char *header = ln_http_build_default_header(ctx->device_id, ctx->device_token, NULL); + if (header) { + printf("device getCharacter header %s\n", header); + } + return header; +} - HTTPC_RESULT prep = ln_http_prepare_auto(&clientData, 2048, 8 * 1024); - if (prep != HTTP_SUCCESS) +/* 响应处理回调 */ +static uint32_t handle_get_character_response(const char *response_data, int response_len, + int status_code, void *user_data) +{ + if (status_code != 200) { - printf("device getCharacter prepare failed %d\n", prep); + printf("device getCharacter: HTTP %d\n", status_code); return ERRCODE_FAIL; } - HTTPC_RESULT res = HttpClientGetRequest(&client, LN_DEVICE_GET_CHARACTER_URL, &clientData); - if (res != HTTP_SUCCESS) - { - printf("device getCharacter get failed %d\n", res); - goto end; - } - int code = HttpClientGetResponseCode(&client); - if (code != 200) - { - printf("device getCharacter: HTTP %d\n", code); - goto end; - } - - if (clientData.responseBuf && clientData.responseBufLen > 0) + if (response_data && response_len > 0) { - int real_len = clientData.responseContentLen > 0 ? clientData.responseContentLen : clientData.responseBufLen; - ln_parse_character_config_startUp(clientData.responseBuf, real_len); + ln_parse_character_config_startUp(response_data, response_len); + return ERRCODE_SUCC; } -end: - HttpClientUnprepare(&clientData); - HttpClientClse(&client); - free(header_buf); - return ERRCODE_SUCC; + return ERRCODE_FAIL; } -// 获取设备绑定用户ID -uint32_t ln_device_get_user_id_http(const char *device_id, - const char *device_token) +uint32_t ln_device_get_character_http(const char *device_id, + const char *device_token) { if (!device_id || !device_token) return ERRCODE_FAIL; -#ifdef SUPPORT_CAT1_SERVICE - /* CAT1 保活 */ - cat1_api_add_cat1_vote(); - cat1_api_disable_cat1_cmd(0); - LOS_Msleep(200); -#endif - - HttpClient client = (HttpClient){0}; - HttpClientData clientData = (HttpClientData){0}; - client.isHttp = false; - client.remotePort = 443; - - char *header_buf2 = (char *)malloc(512); - if (!header_buf2) - return ERRCODE_FAIL; - int hdr = snprintf(header_buf2, 512, - "deviceId: %s\r\n" - "deviceToken: %s\r\n" - "Content-Type: application/json\r\n", - device_id, device_token); - if (hdr <= 0) - { - free(header_buf2); - return ERRCODE_FAIL; - } - HttpClientSetCustomHeader(&client, header_buf2); + device_header_ctx_t header_ctx = { + .device_id = device_id, + .device_token = device_token + }; + + ln_http_request_t req = { + .url = LN_DEVICE_GET_CHARACTER_URL, + .method = LN_HTTP_METHOD_GET, + .is_https = true, + .header_size = 2048, + .response_size = 8 * 1024, + .build_header_cb = build_device_header, + .response_handler_cb = handle_get_character_response, + .user_data = &header_ctx, + .enable_cat1_keepalive = true + }; + + return ln_http_client_request(&req); +} - printf("device getUserId header %s\n", header_buf2); +/* Header构建回调(用于get_user_id) */ +static char* build_device_user_id_header(void *user_data) +{ + device_header_ctx_t *ctx = (device_header_ctx_t*)user_data; + char *header = ln_http_build_default_header(ctx->device_id, ctx->device_token, NULL); + if (header) { + printf("device getUserId header %s\n", header); + } + return header; +} - HTTPC_RESULT prep = ln_http_prepare_auto(&clientData, 2048, 8 * 1024); - if (prep != HTTP_SUCCESS) +/* 响应处理回调 */ +static uint32_t handle_get_user_id_response(const char *response_data, int response_len, + int status_code, void *user_data) +{ + if (status_code != 200) { - printf("device getUserId prepare failed %d\n", prep); + printf("device getUserId: HTTP %d\n", status_code); return ERRCODE_FAIL; } - HTTPC_RESULT res = HttpClientGetRequest(&client, LN_DEVICE_GET_USER_ID_URL, &clientData); - if (res != HTTP_SUCCESS) + if (response_data && response_len > 0) { - printf("device getUserId get failed %d\n", res); - goto end; - } - int code = HttpClientGetResponseCode(&client); - if (code != 200) - { - printf("device getUserId: HTTP %d\n", code); - goto end; - } - - if (clientData.responseBuf && clientData.responseBufLen > 0) - { - int real_len = clientData.responseContentLen > 0 ? clientData.responseContentLen : clientData.responseBufLen; - char *buf = (char *)malloc((size_t)real_len + 1); - if (buf) + char *buf = (char *)malloc((size_t)response_len + 1); + if (!buf) { - memcpy(buf, clientData.responseBuf, (size_t)real_len); - buf[real_len] = '\0'; - cJSON *root = cJSON_Parse(buf); - if (root) + return ERRCODE_FAIL; + } + memcpy(buf, response_data, (size_t)response_len); + buf[response_len] = '\0'; + cJSON *root = cJSON_Parse(buf); + if (root) + { + cJSON *data = cJSON_GetObjectItem(root, "data"); + cJSON *errorCode = cJSON_GetObjectItem(root, "errorCode"); + cJSON *message = cJSON_GetObjectItem(root, "message"); + // 检查errorCode是否为空 + if (errorCode && cJSON_IsString(errorCode)) { - cJSON *data = cJSON_GetObjectItem(root, "data"); - cJSON *errorCode = cJSON_GetObjectItem(root, "errorCode"); - cJSON *message = cJSON_GetObjectItem(root, "message"); - // 检查errorCode是否为空 - if (errorCode && cJSON_IsString(errorCode)) + // 推送协议错误通知到UI + printf("device getUserId: errorCode=%s\n", errorCode->valuestring); + if (message && cJSON_IsString(message)) { - // 推送协议错误通知到UI - printf("device getUserId: errorCode=%s\n", errorCode->valuestring); printf("device getUserId: message=%s\n", message->valuestring); } - else + } + else + { + if (data == NULL || cJSON_IsNull(data)) + { + push_bind_and_unbind_notification(LN_DEVICE_BIND_STATUS_UNBOUND); + uapi_ln_set_device_bound(0); + } + else if (cJSON_IsString(data) && data->valuestring && data->valuestring[0]) { - if (data == NULL || cJSON_IsNull(data)) - { - push_bind_and_unbind_notification(LN_DEVICE_BIND_STATUS_UNBOUND); - uapi_ln_set_device_bound(0); - } - else if (cJSON_IsString(data) && data->valuestring && data->valuestring[0]) - { - printf("device getUserId: data=%s\n", data->valuestring); - do_ln_http_server_send_data(LN_HTTP_SERVICE_CMD_GET_CHARACTER, NULL, 0); - push_bind_and_unbind_notification(LN_DEVICE_BIND_STATUS_BOUND); - uapi_ln_set_device_bound(1); - } + printf("device getUserId: data=%s\n", data->valuestring); + do_ln_http_server_send_data(LN_HTTP_SERVICE_CMD_GET_CHARACTER, NULL, 0); + push_bind_and_unbind_notification(LN_DEVICE_BIND_STATUS_BOUND); + uapi_ln_set_device_bound(1); } - cJSON_Delete(root); } - free(buf); + cJSON_Delete(root); } + free(buf); + return ERRCODE_SUCC; } -end: - HttpClientUnprepare(&clientData); - HttpClientClse(&client); - free(header_buf2); - return ERRCODE_SUCC; + return ERRCODE_FAIL; } -// 获取对话体力与流量信息 -uint32_t ln_device_get_chat_stamina_http(const char *device_id, const char *device_token) +// 获取设备绑定用户ID +uint32_t ln_device_get_user_id_http(const char *device_id, + const char *device_token) { if (!device_id || !device_token) - { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[CHAT_STAMINA] missing deviceId/token"); - return ERRCODE_FAIL; - } - -#ifdef SUPPORT_CAT1_SERVICE - cat1_api_add_cat1_vote(); - cat1_api_disable_cat1_cmd(0); - LOS_Msleep(200); -#endif - - HttpClient client = (HttpClient){0}; - HttpClientData clientData = (HttpClientData){0}; - client.isHttp = false; - client.remotePort = 443; - - char *header_buf = (char *)malloc(512); - if (!header_buf) - { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[CHAT_STAMINA] malloc failed for header_buf"); - return ERRCODE_FAIL; - } - int hdr = snprintf(header_buf, 512, - "deviceId: %s\r\n" - "deviceToken: %s\r\n" - "Content-Type: application/json\r\n", - device_id, device_token); - if (hdr <= 0) - { - free(header_buf); - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[CHAT_STAMINA] snprintf failed for header_buf"); return ERRCODE_FAIL; - } - HttpClientSetCustomHeader(&client, header_buf); - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[CHAT_STAMINA] header_buf: %s", header_buf); - HTTPC_RESULT prep = ln_http_prepare_auto(&clientData, 2048, LN_CLIENT_PREPARE_SIZE * 2); - if (prep != HTTP_SUCCESS) - { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[CHAT_STAMINA] prepare failed: %d", prep); - free(header_buf); - return ERRCODE_FAIL; - } + device_header_ctx_t header_ctx = { + .device_id = device_id, + .device_token = device_token + }; + + ln_http_request_t req = { + .url = LN_DEVICE_GET_USER_ID_URL, + .method = LN_HTTP_METHOD_GET, + .is_https = true, + .header_size = 2048, + .response_size = 8 * 1024, + .build_header_cb = build_device_user_id_header, + .response_handler_cb = handle_get_user_id_response, + .user_data = &header_ctx, + .enable_cat1_keepalive = true + }; + + return ln_http_client_request(&req); +} - HTTPC_RESULT res = HttpClientGetRequest(&client, LN_DEVICE_GET_CHAT_STAMINA_URL, &clientData); - if (res != HTTP_SUCCESS) - { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[CHAT_STAMINA] request failed: %d", res); - HttpClientUnprepare(&clientData); - HttpClientClse(&client); - free(header_buf); - return ERRCODE_FAIL; +/* Header构建回调(用于get_chat_stamina) */ +static char* build_chat_stamina_header(void *user_data) +{ + device_header_ctx_t *ctx = (device_header_ctx_t*)user_data; + char *header = ln_http_build_default_header(ctx->device_id, ctx->device_token, NULL); + if (header) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[CHAT_STAMINA] header_buf: %s", header); } + return header; +} - int code = HttpClientGetResponseCode(&client); - int body_len = clientData.responseContentLen > 0 ? clientData.responseContentLen : clientData.responseBufLen; - if (body_len <= 0 || !clientData.responseBuf) +/* 响应处理回调 */ +static uint32_t handle_chat_stamina_response(const char *response_data, int response_len, + int status_code, void *user_data) +{ + if (response_data == NULL || response_len <= 0) { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[CHAT_STAMINA] empty body, code=%d", code); - HttpClientUnprepare(&clientData); - HttpClientClse(&client); - free(header_buf); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[CHAT_STAMINA] empty body, code=%d", status_code); return ERRCODE_FAIL; } - char *json_text = (char *)malloc((size_t)body_len + 1); + char *json_text = (char *)malloc((size_t)response_len + 1); if (!json_text) { - HttpClientUnprepare(&clientData); - HttpClientClse(&client); - free(header_buf); return ERRCODE_FAIL; } - memcpy(json_text, clientData.responseBuf, (size_t)body_len); - json_text[body_len] = '\0'; + memcpy(json_text, response_data, (size_t)response_len); + json_text[response_len] = '\0'; /* 若非200,打印原始响应体便于排查 */ - if (code != 200) + if (status_code != 200) { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[CHAT_STAMINA] HTTP code=%d", code); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[CHAT_STAMINA] HTTP code=%d", status_code); WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[CHAT_STAMINA] body=%s", json_text); + free(json_text); + return ERRCODE_FAIL; } cJSON *root = cJSON_Parse(json_text); @@ -731,9 +685,6 @@ uint32_t ln_device_get_chat_stamina_http(const char *device_id, const char *devi WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[CHAT_STAMINA] json parse failed"); WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[CHAT_STAMINA] raw body: %s", json_text); free(json_text); - HttpClientUnprepare(&clientData); - HttpClientClse(&client); - free(header_buf); return ERRCODE_FAIL; } @@ -744,12 +695,8 @@ uint32_t ln_device_get_chat_stamina_http(const char *device_id, const char *devi WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[CHAT_STAMINA] server error: %s, msg=%s", cJSON_IsString(errorCode) ? errorCode->valuestring : "", (message && cJSON_IsString(message)) ? message->valuestring : ""); - cJSON_Delete(root); free(json_text); - HttpClientUnprepare(&clientData); - HttpClientClse(&client); - free(header_buf); return ERRCODE_FAIL; } @@ -759,9 +706,6 @@ uint32_t ln_device_get_chat_stamina_http(const char *device_id, const char *devi WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[CHAT_STAMINA] no data"); cJSON_Delete(root); free(json_text); - HttpClientUnprepare(&clientData); - HttpClientClse(&client); - free(header_buf); return ERRCODE_FAIL; } @@ -788,8 +732,34 @@ uint32_t ln_device_get_chat_stamina_http(const char *device_id, const char *devi cJSON_Delete(root); free(json_text); - HttpClientUnprepare(&clientData); - HttpClientClse(&client); - free(header_buf); return ERRCODE_SUCC; +} + +// 获取对话体力与流量信息 +uint32_t ln_device_get_chat_stamina_http(const char *device_id, const char *device_token) +{ + if (!device_id || !device_token) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[CHAT_STAMINA] missing deviceId/token"); + return ERRCODE_FAIL; + } + + device_header_ctx_t header_ctx = { + .device_id = device_id, + .device_token = device_token + }; + + ln_http_request_t req = { + .url = LN_DEVICE_GET_CHAT_STAMINA_URL, + .method = LN_HTTP_METHOD_GET, + .is_https = true, + .header_size = 2048, + .response_size = LN_CLIENT_PREPARE_SIZE * 2, + .build_header_cb = build_chat_stamina_header, + .response_handler_cb = handle_chat_stamina_response, + .user_data = &header_ctx, + .enable_cat1_keepalive = true + }; + + return ln_http_client_request(&req); } \ No newline at end of file diff --git a/code/sdk/zhihui/leiniao/imsl_ln/ln_api_emoji.c b/code/sdk/zhihui/leiniao/imsl_ln/ln_api_emoji.c index 227ff2e25..6bea265d8 100644 --- a/code/sdk/zhihui/leiniao/imsl_ln/ln_api_emoji.c +++ b/code/sdk/zhihui/leiniao/imsl_ln/ln_api_emoji.c @@ -1,4 +1,5 @@ #include "ln_api.h" +#include "ln_http_client.h" #include #include #include @@ -10,6 +11,10 @@ #include #include "custom_utils.h" #include +/* 使用extern声明,避免依赖具体实现(PPP或cat1Service) */ +#if defined(SUPPORT_CAT1_SERVICE) || defined(SUPPORT_PPP_SERVICE) +extern void cat1_api_keep_wakeup(uint8_t keep_wakeup); +#endif /* 宏定义 */ #define MAX_PATH_LEN 512 // 最大路径长度 @@ -662,14 +667,30 @@ void ln_start_emoji_download(void) { WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD] 启动表情下载任务"); uapi_ln_set_file_download_type(LN_FILE_DOWNLOAD_TYPE_EMOJI); + +#if defined(SUPPORT_CAT1_SERVICE) || defined(SUPPORT_PPP_SERVICE) + /* 保持CAT1唤醒,防止批量下载过程中休眠 */ + cat1_api_keep_wakeup(1); +#endif + if (g_emoji_package.emojiCount <= 0 || !g_emoji_package.emojis) { WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[DOWNLOAD] no emojis to download"); + uapi_ln_set_file_download_type(LN_FILE_DOWNLOAD_TYPE_NONE); +#if defined(SUPPORT_CAT1_SERVICE) || defined(SUPPORT_PPP_SERVICE) + /* 释放CAT1唤醒,允许休眠 */ + cat1_api_keep_wakeup(0); +#endif return; } // 下载表情 ln_emoji_download(&g_emoji_package); uapi_ln_set_file_download_type(LN_FILE_DOWNLOAD_TYPE_NONE); + +#if defined(SUPPORT_CAT1_SERVICE) || defined(SUPPORT_PPP_SERVICE) + /* 释放CAT1唤醒,允许休眠 */ + cat1_api_keep_wakeup(0); +#endif } /* 解析下载表情命令JSON */ @@ -1011,6 +1032,106 @@ void ln_parse_delete_emoji(const char *json_buf, int json_len) } } +/* Header构建上下文(用于emoji) */ +typedef struct { + const char *device_id; + const char *device_token; +} emoji_header_ctx_t; + +/* Body构建上下文(用于emoji_report_status) */ +typedef struct { + const char *character_id; + const char *eyes_color; + const char *eyes_shape; + const char *status; + const char *description; +} emoji_status_body_ctx_t; + +/* 联合上下文(用于emoji_report_status) */ +typedef struct { + emoji_header_ctx_t *header_ctx; + emoji_status_body_ctx_t *body_ctx; +} emoji_status_ctx_t; + +/* Header构建回调(用于emoji_report_status) */ +static char* build_emoji_status_header(void *user_data) +{ + emoji_status_ctx_t *ctx = (emoji_status_ctx_t*)user_data; + if (!ctx || !ctx->header_ctx) + { + return NULL; + } + return ln_http_build_default_header(ctx->header_ctx->device_id, ctx->header_ctx->device_token, NULL); +} + +/* Body构建回调(用于emoji_report_status) */ +static char* build_emoji_status_body(void *user_data, int *body_len_out, + char *content_type_out, int content_type_size) +{ + emoji_status_ctx_t *ctx = (emoji_status_ctx_t*)user_data; + if (!ctx || !ctx->body_ctx) + { + return NULL; + } + emoji_status_body_ctx_t *body_ctx = ctx->body_ctx; + if (!body_ctx || !body_ctx->character_id || !body_ctx->eyes_color || !body_ctx->eyes_shape || !body_ctx->status) + { + return NULL; + } + + cJSON *root = cJSON_CreateObject(); + if (!root) + { + return NULL; + } + cJSON_AddStringToObject(root, "characterId", body_ctx->character_id); + cJSON_AddStringToObject(root, "eyesColor", body_ctx->eyes_color); + cJSON_AddStringToObject(root, "eyesShape", body_ctx->eyes_shape); + cJSON_AddStringToObject(root, "status", body_ctx->status); + cJSON_AddStringToObject(root, "description", body_ctx->description ? body_ctx->description : ""); + char *body = cJSON_PrintUnformatted(root); + cJSON_Delete(root); + + if (body && body_len_out) + { + *body_len_out = (int)strlen(body); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[EMOJI_REPORT_STATUS] request body: %s", body); + } + + if (content_type_out && content_type_size > 0) + { + snprintf(content_type_out, content_type_size, "application/json"); + } + + return body; +} + +/* 响应处理回调(用于emoji_report_status) */ +static uint32_t handle_emoji_status_response(const char *response_data, int response_len, + int status_code, void *user_data) +{ + if (status_code != 200) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[EMOJI_REPORT_STATUS] response code not 200"); + return ERRCODE_FAIL; + } + + if (response_data && response_len > 0) + { + // 打印成功响应 + char *response_buf = (char *)malloc((size_t)response_len + 1); + if (response_buf) + { + memcpy(response_buf, response_data, (size_t)response_len); + response_buf[response_len] = '\0'; + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[EMOJI_REPORT_STATUS] response body: %s", response_buf); + free(response_buf); + } + } + + return ERRCODE_SUCC; +} + /* 7.1 上报角色表情组下载状态(支持 description) */ static uint32_t ln_emoji_report_status_http(const char *device_id, const char *device_token, @@ -1027,122 +1148,146 @@ static uint32_t ln_emoji_report_status_http(const char *device_id, } WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[EMOJI_REPORT_STATUS] starting"); - // CAT1 保活 -#ifdef SUPPORT_CAT1_SERVICE - cat1_api_add_cat1_vote(); - cat1_api_disable_cat1_cmd(0); - LOS_Msleep(200); -#endif - - HttpClient client = (HttpClient){0}; - HttpClientData clientData = (HttpClientData){0}; - - /* 直接构造自定义请求头,生命周期贯穿整个请求,结束后再释放 */ - char *header_buf = (char *)malloc(512); - if (!header_buf) - { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[EMOJI_REPORT_STATUS] malloc header_buf failed"); - return ERRCODE_FAIL; - } - int hdr = snprintf(header_buf, 512, - "deviceId: %s\r\n" - "deviceToken: %s\r\n" - "Content-Type: application/json\r\n", - device_id, device_token); - if (hdr <= 0) - { - free(header_buf); - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[EMOJI_REPORT_STATUS] build header failed"); - return ERRCODE_FAIL; - } - HttpClientSetCustomHeader(&client, header_buf); - /* 组装 JSON */ - cJSON *root = cJSON_CreateObject(); - if (!root) - { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[EMOJI_REPORT_STATUS] create root object failed"); - return ERRCODE_FAIL; - } - cJSON_AddStringToObject(root, "characterId", character_id); - cJSON_AddStringToObject(root, "eyesColor", eyes_color); - cJSON_AddStringToObject(root, "eyesShape", eyes_shape); - cJSON_AddStringToObject(root, "status", status); - cJSON_AddStringToObject(root, "description", description ? description : ""); - char *body = cJSON_PrintUnformatted(root); - cJSON_Delete(root); - if (!body) - { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[EMOJI_REPORT_STATUS] print unformatted failed"); - return ERRCODE_FAIL; - } - - HTTPC_RESULT prep = ln_http_prepare_auto(&clientData, 2048, LN_CLIENT_PREPARE_SIZE / 2); - if (prep != HTTP_SUCCESS) - { - free(body); - free(header_buf); - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[EMOJI_REPORT_STATUS] prepare auto failed"); - return ERRCODE_FAIL; - } - clientData.postBuf = body; - clientData.postBufLen = (int)strlen(body); - clientData.postContentType = (char *)"application/json"; - - // 打印请求请求响应 - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[EMOJI_REPORT_STATUS] request body: %s", body); - // 使用说明: - // - 该接口用于设备向服务器同步表情下载/删除状态 - // - 设备执行表情下载或删除操作成功后,必须调用此接口 - // - 服务器会根据上报的信息更新小程序端的表情状态显示 - // - characterId、eyesColor、eyesShape三个字段组合标识一个唯一的表情组 - - HTTPC_RESULT res = HttpClientPostRequest(&client, LN_EMOJI_REPORT_URL, &clientData); - if (res != HTTP_SUCCESS) - { - free(body); - HttpClientUnprepare(&clientData); - free(header_buf); - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[EMOJI_REPORT_STATUS] request failed"); - return ERRCODE_FAIL; - } - - int code = HttpClientGetResponseCode(&client); - if (code != 200) - { - free(body); - HttpClientUnprepare(&clientData); - free(header_buf); - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[EMOJI_REPORT_STATUS] response code not 200"); - return ERRCODE_FAIL; - } - if (clientData.responseBuf && clientData.responseBufLen > 0) - { - // { - // "errorCode": null, - // "message": null, - // "data": "ok" - // } - // 打印成功响应 - int real_len = clientData.responseContentLen > 0 ? clientData.responseContentLen : clientData.responseBufLen; - char *response_buf = (char *)malloc(real_len + 1); - if (!response_buf) - { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[EMOJI_REPORT_STATUS] malloc failed for response_buf"); - return ERRCODE_FAIL; - } - memcpy(response_buf, clientData.responseBuf, real_len); - response_buf[real_len] = '\0'; - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[EMOJI_REPORT_STATUS] response body: %s", response_buf); - free(response_buf); - } + emoji_header_ctx_t header_ctx = { + .device_id = device_id, + .device_token = device_token + }; + + emoji_status_body_ctx_t body_ctx = { + .character_id = character_id, + .eyes_color = eyes_color, + .eyes_shape = eyes_shape, + .status = status, + .description = description + }; + + emoji_status_ctx_t ctx = { + .header_ctx = &header_ctx, + .body_ctx = &body_ctx + }; + + ln_http_request_t req = { + .url = LN_EMOJI_REPORT_URL, + .method = LN_HTTP_METHOD_POST, + .is_https = true, + .header_size = 2048, + .response_size = LN_CLIENT_PREPARE_SIZE / 2, + .build_header_cb = build_emoji_status_header, + .build_body_cb = build_emoji_status_body, + .response_handler_cb = handle_emoji_status_response, + .user_data = &ctx, + .enable_cat1_keepalive = true + }; + + return ln_http_client_request(&req); +} +/* Body构建上下文(用于emoji_report_all) */ +typedef struct { + const LnEmojiGroup *groups; + int group_count; +} emoji_all_body_ctx_t; + +/* 联合上下文(用于emoji_report_all) */ +typedef struct { + emoji_header_ctx_t *header_ctx; + emoji_all_body_ctx_t *body_ctx; +} emoji_all_ctx_t; + +/* Header构建回调(用于emoji_report_all) */ +static char* build_emoji_all_header(void *user_data) +{ + emoji_all_ctx_t *ctx = (emoji_all_ctx_t*)user_data; + if (!ctx || !ctx->header_ctx) + { + return NULL; + } + return ln_http_build_default_header(ctx->header_ctx->device_id, ctx->header_ctx->device_token, NULL); +} +/* Body构建回调(用于emoji_report_all) */ +static char* build_emoji_all_body(void *user_data, int *body_len_out, + char *content_type_out, int content_type_size) +{ + emoji_all_ctx_t *ctx = (emoji_all_ctx_t*)user_data; + if (!ctx || !ctx->body_ctx) + { + return NULL; + } + emoji_all_body_ctx_t *body_ctx = ctx->body_ctx; + if (!body_ctx->groups || body_ctx->group_count <= 0) + { + return NULL; + } + + /* 组装 JSON 数组 */ + cJSON *root = cJSON_CreateObject(); + if (!root) + { + return NULL; + } + cJSON *arr = cJSON_CreateArray(); + if (!arr) + { + cJSON_Delete(root); + return NULL; + } + for (int i = 0; i < body_ctx->group_count; ++i) + { + cJSON *item = cJSON_CreateObject(); + if (!item) + { + continue; + } + cJSON_AddStringToObject(item, "characterId", body_ctx->groups[i].characterId ? body_ctx->groups[i].characterId : ""); + cJSON_AddStringToObject(item, "eyesColor", body_ctx->groups[i].eyesColor ? body_ctx->groups[i].eyesColor : ""); + cJSON_AddStringToObject(item, "eyesShape", body_ctx->groups[i].eyesShape ? body_ctx->groups[i].eyesShape : ""); + cJSON_AddStringToObject(item, "status", body_ctx->groups[i].status ? body_ctx->groups[i].status : ""); + cJSON_AddItemToArray(arr, item); + } + cJSON_AddItemToObject(root, "emojiGroups", arr); + char *body = cJSON_PrintUnformatted(root); + cJSON_Delete(root); + + if (body && body_len_out) + { + *body_len_out = (int)strlen(body); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[EMOJI_REPORT_ALL] request body: %s", body); + } + + if (content_type_out && content_type_size > 0) + { + snprintf(content_type_out, content_type_size, "application/json"); + } + + return body; +} - free(body); - HttpClientUnprepare(&clientData); - free(header_buf); - return ERRCODE_SUCC; +/* 响应处理回调(用于emoji_report_all) */ +static uint32_t handle_emoji_all_response(const char *response_data, int response_len, + int status_code, void *user_data) +{ + if (status_code != 200) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[EMOJI_REPORT_ALL] HTTP %d", status_code); + return ERRCODE_FAIL; + } + + if (response_data && response_len > 0) + { + char *response_buf = (char *)malloc((size_t)response_len + 1); + if (response_buf) + { + memcpy(response_buf, response_data, (size_t)response_len); + response_buf[response_len] = '\0'; + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[EMOJI_REPORT_STATUS] response body: %s", response_buf); + free(response_buf); + } + } + + return ERRCODE_SUCC; } + /* 7.2 上报设备所有表情组状态 */ static uint32_t ln_emoji_report_all_http(const char *device_id, const char *device_token, @@ -1152,113 +1297,35 @@ static uint32_t ln_emoji_report_all_http(const char *device_id, if (!device_id || !device_token || (!groups && group_count > 0) || group_count < 0) return ERRCODE_FAIL; -#ifdef SUPPORT_CAT1_SERVICE - cat1_api_add_cat1_vote(); - cat1_api_disable_cat1_cmd(0); - LOS_Msleep(200); -#endif - - HttpClient client = (HttpClient){0}; - HttpClientData clientData = (HttpClientData){0}; - client.isHttp = false; - client.remotePort = 443; - - /* 直接构造自定义请求头,生命周期贯穿整个请求,结束后再释放 */ - char *header_buf = (char *)malloc(512); - if (!header_buf) - return ERRCODE_FAIL; - int hdr = snprintf(header_buf, 512, - "deviceId: %s\r\n" - "deviceToken: %s\r\n" - "Content-Type: application/json\r\n", - device_id, device_token); - if (hdr <= 0) - { - free(header_buf); - return ERRCODE_FAIL; - } - HttpClientSetCustomHeader(&client, header_buf); - - /* 组装 JSON 数组 */ - cJSON *root = cJSON_CreateObject(); - if (!root) - return ERRCODE_FAIL; - cJSON *arr = cJSON_CreateArray(); - if (!arr) - { - cJSON_Delete(root); - return ERRCODE_FAIL; - } - for (int i = 0; i < group_count; ++i) - { - cJSON *item = cJSON_CreateObject(); - if (!item) - { - continue; - } - cJSON_AddStringToObject(item, "characterId", groups[i].characterId ? groups[i].characterId : ""); - cJSON_AddStringToObject(item, "eyesColor", groups[i].eyesColor ? groups[i].eyesColor : ""); - cJSON_AddStringToObject(item, "eyesShape", groups[i].eyesShape ? groups[i].eyesShape : ""); - cJSON_AddStringToObject(item, "status", groups[i].status ? groups[i].status : ""); - cJSON_AddItemToArray(arr, item); - } - cJSON_AddItemToObject(root, "emojiGroups", arr); - char *body = cJSON_PrintUnformatted(root); - cJSON_Delete(root); - if (!body) - return ERRCODE_FAIL; - - HTTPC_RESULT prep = ln_http_prepare_auto(&clientData, 2048, LN_CLIENT_PREPARE_SIZE * 2); - if (prep != HTTP_SUCCESS) - { - free(body); - free(header_buf); - return ERRCODE_FAIL; - } - clientData.postBuf = body; - clientData.postBufLen = (int)strlen(body); - clientData.postContentType = (char *)"application/json"; - - //打印请求体 - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[EMOJI_REPORT_ALL] request body: %s", body); - - HTTPC_RESULT res = HttpClientPostRequest(&client, LN_EMOJI_REPORT_ALL_URL, &clientData); - if (res != HTTP_SUCCESS) - { - free(body); - HttpClientUnprepare(&clientData); - free(header_buf); - return ERRCODE_FAIL; - } - - int code = HttpClientGetResponseCode(&client); - if (code != 200) - { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[EMOJI_REPORT_ALL] HTTP %d", code); - free(body); - HttpClientUnprepare(&clientData); - free(header_buf); - return ERRCODE_FAIL; - } - if (clientData.responseBuf && clientData.responseBufLen > 0) - { - int real_len = clientData.responseContentLen > 0 ? clientData.responseContentLen : clientData.responseBufLen; - char *response_buf = (char *)malloc(real_len + 1); - if (!response_buf) - { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[EMOJI_REPORT_STATUS] malloc failed for response_buf"); - return ERRCODE_FAIL; - } - memcpy(response_buf, clientData.responseBuf, real_len); - response_buf[real_len] = '\0'; - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[EMOJI_REPORT_STATUS] response body: %s", response_buf); - free(response_buf); - } - - free(body); - HttpClientUnprepare(&clientData); - free(header_buf); - return ERRCODE_SUCC; + emoji_header_ctx_t header_ctx = { + .device_id = device_id, + .device_token = device_token + }; + + emoji_all_body_ctx_t body_ctx = { + .groups = groups, + .group_count = group_count + }; + + emoji_all_ctx_t ctx = { + .header_ctx = &header_ctx, + .body_ctx = &body_ctx + }; + + ln_http_request_t req = { + .url = LN_EMOJI_REPORT_ALL_URL, + .method = LN_HTTP_METHOD_POST, + .is_https = true, + .header_size = 2048, + .response_size = LN_CLIENT_PREPARE_SIZE * 2, + .build_header_cb = build_emoji_all_header, + .build_body_cb = build_emoji_all_body, + .response_handler_cb = handle_emoji_all_response, + .user_data = &ctx, + .enable_cat1_keepalive = true + }; + + return ln_http_client_request(&req); } /* 上报角色表情组下载/删除状态 */ diff --git a/code/sdk/zhihui/leiniao/imsl_ln/ln_api_ota.c b/code/sdk/zhihui/leiniao/imsl_ln/ln_api_ota.c index f394b3986..7d916b889 100644 --- a/code/sdk/zhihui/leiniao/imsl_ln/ln_api_ota.c +++ b/code/sdk/zhihui/leiniao/imsl_ln/ln_api_ota.c @@ -1,4 +1,5 @@ #include "ln_api.h" +#include "ln_http_client.h" #include #include #include "upg_common_porting.h" /* 使用统一的 UPG_FILE_NAME 路径宏 */ @@ -7,6 +8,11 @@ #include "errcode.h" #include "custom_utils.h" #include "cJSON.h" +#include "watchdog.h" /* 用于看门狗喂狗 */ +/* 使用extern声明,避免依赖具体实现(PPP或cat1Service) */ +#if defined(SUPPORT_CAT1_SERVICE) || defined(SUPPORT_PPP_SERVICE) +extern void cat1_api_keep_wakeup(uint8_t keep_wakeup); +#endif /* OTA下载状态枚举(对应时序图中的下载阶段)*/ typedef enum @@ -34,15 +40,15 @@ static int ln_calc_file_md5_lower_hex(const char *file_path, char out_hex[33]) if (!fp) return -1; mbedtls_md5_context ctx; mbedtls_md5_init(&ctx); - if (mbedtls_md5_starts(&ctx) != 0) { mbedtls_md5_free(&ctx); fclose(fp); return -1; } + mbedtls_md5_starts(&ctx); unsigned char buf[1024]; size_t n; while ((n = fread(buf, 1, sizeof(buf), fp)) > 0) { - if (mbedtls_md5_update(&ctx, buf, n) != 0) { mbedtls_md5_free(&ctx); fclose(fp); return -1; } + mbedtls_md5_update(&ctx, buf, n); } fclose(fp); unsigned char md5_ctx_buf[16]; - if (mbedtls_md5_finish(&ctx, md5_ctx_buf) != 0) { mbedtls_md5_free(&ctx); return -1; } + mbedtls_md5_finish(&ctx, md5_ctx_buf); mbedtls_md5_free(&ctx); static const char hex[] = "0123456789abcdef"; for (int i = 0; i < 16; i++) { @@ -98,18 +104,18 @@ static void ln_ota_handle_download_msg(const OtaDownloadMsg *msg) (void)uaip_cmd_update_request(); } else if (md5_ok == 0) { WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"[OTA_DOWNLOAD] MD5校验失败,建议重新下载"); - uapi_pm_remove_sleep_veto(PM_ID_DEBUG); + cat1_api_remove_cat1_app_vote(); push_ota_status(OTA_UI_STATUS_FAILED); } else { WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"[OTA_DOWNLOAD] MD5校验出错"); - uapi_pm_remove_sleep_veto(PM_ID_DEBUG); + cat1_api_remove_cat1_app_vote(); push_ota_status(OTA_UI_STATUS_FAILED); } } break; case OTA_DOWNLOAD_STATUS_FAILED: WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"[OTA_DOWNLOAD] 下载失败: %s", msg->error_msg); - uapi_pm_remove_sleep_veto(PM_ID_DEBUG); + cat1_api_remove_cat1_app_vote(); push_ota_status(OTA_UI_STATUS_FAILED); break; default: @@ -230,6 +236,52 @@ static void ln_handle_ota_task_response(const char *json_buf, int json_len) free(text); } +/* Header构建上下文(用于OTA) */ +typedef struct { + const char *device_id; + const char *device_token; +} ota_header_ctx_t; + +/* Header构建回调(用于OTA,带设备信息) */ +static char* build_ota_header(void *user_data) +{ + ota_header_ctx_t *ctx = (ota_header_ctx_t*)user_data; + return ln_http_build_device_header(ctx->device_id, ctx->device_token, NULL); +} + +/* URL构建上下文 */ +typedef struct { + const char *base_url; + const char *device_id; + const char *source_version; + char *url_buf; // 需要释放 +} ota_url_ctx_t; + +/* 响应处理回调 */ +static uint32_t handle_ota_task_response(const char *response_data, int response_len, + int status_code, void *user_data) +{ + if (!response_data || response_len <= 0) + { + return ERRCODE_FAIL; + } + + int real_len = response_len; + if (real_len <= 0) + real_len = (int)strlen(response_data); + + if (status_code != 200) + { + printf("[OTA] HttpClientGetResponseCode %d\n", status_code); + // 即使不是200,也尝试解析响应 + ln_handle_ota_task_response(response_data, real_len); + return ERRCODE_FAIL; + } + + ln_handle_ota_task_response(response_data, real_len); + return ERRCODE_SUCC; +} + uint32_t ln_ota_get_task_http(const char *device_id, const char *device_token, const char *source_version) @@ -237,55 +289,16 @@ uint32_t ln_ota_get_task_http(const char *device_id, if (!device_id || !device_token || !source_version) return ERRCODE_FAIL; -#ifdef SUPPORT_CAT1_SERVICE - /* CAT1 保活 */ - cat1_api_add_cat1_vote(); - cat1_api_disable_cat1_cmd(0); - LOS_Msleep(200); -#endif - - HttpClient client = (HttpClient){0}; - HttpClientData clientData = (HttpClientData){0}; - client.isHttp = false; - client.remotePort = 443; - - /* 头:与 device info 一致,额外带 model/version 可辅助服务端日志定位 */ - size_t hdr_cap = 64 + strlen(device_id) + strlen(device_token) + - (uapi_ln_get_device_model() ? strlen(uapi_ln_get_device_model()) : 5) + - (uapi_ln_get_device_version() ? strlen(uapi_ln_get_device_version()) : 5); - char *header_buf = (char *)malloc(hdr_cap + 128); - if (!header_buf) - return ERRCODE_FAIL; - int hdr = snprintf(header_buf, hdr_cap + 128, - "deviceId: %s\r\n" - "deviceToken: %s\r\n" - "deviceModel: %s\r\n" - "deviceVersion: %s\r\n" - "Content-Type: application/json\r\n", - device_id, device_token, - (uapi_ln_get_device_model() ? uapi_ln_get_device_model() : "AB101"), - (uapi_ln_get_device_version() ? uapi_ln_get_device_version() : "1.0.0")); - if (hdr <= 0) - { - free(header_buf); - return ERRCODE_FAIL; - } - HttpClientSetCustomHeader(&client, header_buf); - - HTTPC_RESULT prep = ln_http_prepare_auto(&clientData, 2048, 8 * 1024); - if (prep != HTTP_SUCCESS) - { - printf("[OTA] getTask prepare failed %d\n", prep); - return ERRCODE_FAIL; - } + ota_header_ctx_t header_ctx = { + .device_id = device_id, + .device_token = device_token + }; /* 拼 GET URL 参数 */ size_t url_cap = strlen(LN_OTA_GET_TASK_URL) + strlen(device_id) + strlen(source_version) + 64; char *url_with_params = (char *)malloc(url_cap); if (!url_with_params) { - HttpClientUnprepare(&clientData); - free(header_buf); return ERRCODE_FAIL; } int ulen = snprintf(url_with_params, url_cap, @@ -293,47 +306,27 @@ uint32_t ln_ota_get_task_http(const char *device_id, LN_OTA_GET_TASK_URL, device_id, source_version); if (ulen <= 0 || (size_t)ulen >= url_cap) { - HttpClientUnprepare(&clientData); - free(header_buf); free(url_with_params); return ERRCODE_FAIL; } printf("[OTA] GET %s\n", url_with_params); - HTTPC_RESULT res = HttpClientGetRequest(&client, url_with_params, &clientData); - if (res != HTTP_SUCCESS) - { - printf("[OTA] HttpClientGetRequest error %d\n", res); - goto end; - } - - int code = HttpClientGetResponseCode(&client); - if (code != 200) - { - printf("[OTA] HttpClientGetResponseCode %d\n", code); - if (clientData.responseBuf && clientData.responseBufLen > 0) - { - int real_len = clientData.responseContentLen > 0 ? clientData.responseContentLen : clientData.responseBufLen; - ln_handle_ota_task_response(clientData.responseBuf, real_len); - } - goto end; - } - - if (clientData.responseBuf && clientData.responseBufLen > 0) - { - int real_len = clientData.responseContentLen > 0 ? clientData.responseContentLen : clientData.responseBufLen; - ln_handle_ota_task_response(clientData.responseBuf, real_len); - } - -end: - HttpClientUnprepare(&clientData); - HttpClientClse(&client); - if (header_buf) - free(header_buf); - if (url_with_params) - free(url_with_params); - return ERRCODE_SUCC; + ln_http_request_t req = { + .url = url_with_params, + .method = LN_HTTP_METHOD_GET, + .is_https = true, + .header_size = 2048, + .response_size = 8 * 1024, + .build_header_cb = build_ota_header, + .response_handler_cb = handle_ota_task_response, + .user_data = &header_ctx, + .enable_cat1_keepalive = true + }; + + uint32_t result = ln_http_client_request(&req); + free(url_with_params); + return result; } /* 采用http_download风格实现的文件下载函数 @@ -355,13 +348,14 @@ static int ln_download_file_to_path(const char *full_url, const char *save_path, printf("[OTA] starting download: %s -> %s, total_size=%d bytes\n", full_url, save_path, total_size); -#ifdef SUPPORT_CAT1_SERVICE +#if defined(SUPPORT_CAT1_SERVICE) || defined(SUPPORT_PPP_SERVICE) /* CAT1 网络保活处理 */ - cat1_api_add_cat1_vote(); + cat1_api_add_cat1_app_vote(); cat1_api_disable_cat1_cmd(0); + /* 保持CAT1唤醒,防止下载过程中休眠 */ + cat1_api_keep_wakeup(1); LOS_Msleep(500); // 等待模块就绪 #endif - uapi_pm_add_sleep_veto(PM_ID_DEBUG); /* 初始化HTTP客户端(与http_download风格一致) */ HttpClient client = {0}; @@ -369,6 +363,9 @@ static int ln_download_file_to_path(const char *full_url, const char *save_path, int ret = -1; size_t total_written = 0; // 本次会话写入的字节数 int last_percent = -1; // 上次上报的进度百分比 + uint32_t last_progress_update_time = 0; // 上次进度更新时间(毫秒) + #define PROGRESS_UPDATE_INTERVAL_MS 500 // 进度更新间隔:500ms + #define PROGRESS_UPDATE_THRESHOLD 2 // 进度更新阈值:2% /* 计算断点偏移:已存在部分文件则续传 */ long long resume_offset = 0; @@ -391,6 +388,10 @@ static int ln_download_file_to_path(const char *full_url, const char *save_path, if (resume_offset >= (long long)total_size) { printf("[OTA] local file already complete: %lld >= %d\n", resume_offset, total_size); +#if defined(SUPPORT_CAT1_SERVICE) || defined(SUPPORT_PPP_SERVICE) + cat1_api_keep_wakeup(0); + cat1_api_remove_cat1_app_vote(); +#endif return 0; // 视为已完成 } } @@ -400,6 +401,9 @@ static int ln_download_file_to_path(const char *full_url, const char *save_path, if (!fd) { printf("[OTA] fopen failed for %s:\n", save_path); +#if defined(SUPPORT_CAT1_SERVICE) || defined(SUPPORT_PPP_SERVICE) + cat1_api_keep_wakeup(0); +#endif return -1; } @@ -408,6 +412,9 @@ static int ln_download_file_to_path(const char *full_url, const char *save_path, { printf("[OTA] range prepare failed: %d\n", prep); fclose(fd); +#if defined(SUPPORT_CAT1_SERVICE) || defined(SUPPORT_PPP_SERVICE) + cat1_api_keep_wakeup(0); +#endif return -1; } @@ -420,6 +427,9 @@ static int ln_download_file_to_path(const char *full_url, const char *save_path, { HttpClientUnprepare(&client_data); fclose(fd); +#if defined(SUPPORT_CAT1_SERVICE) || defined(SUPPORT_PPP_SERVICE) + cat1_api_keep_wakeup(0); +#endif return -1; } int hdr = snprintf(header_buf, 128, "Range: bytes=%lld-\r\n", resume_offset); @@ -428,6 +438,9 @@ static int ln_download_file_to_path(const char *full_url, const char *save_path, free(header_buf); HttpClientUnprepare(&client_data); fclose(fd); +#if defined(SUPPORT_CAT1_SERVICE) || defined(SUPPORT_PPP_SERVICE) + cat1_api_keep_wakeup(0); +#endif return -1; } HttpClientSetCustomHeader(&client, header_buf); @@ -441,6 +454,9 @@ static int ln_download_file_to_path(const char *full_url, const char *save_path, if (header_buf) free(header_buf); fclose(fd); HttpClientUnprepare(&client_data); +#if defined(SUPPORT_CAT1_SERVICE) || defined(SUPPORT_PPP_SERVICE) + cat1_api_keep_wakeup(0); +#endif return ret; } @@ -453,6 +469,9 @@ static int ln_download_file_to_path(const char *full_url, const char *save_path, HttpClientClse(&client); fclose(fd); HttpClientUnprepare(&client_data); +#if defined(SUPPORT_CAT1_SERVICE) || defined(SUPPORT_PPP_SERVICE) + cat1_api_keep_wakeup(0); +#endif return ret; } @@ -466,6 +485,9 @@ static int ln_download_file_to_path(const char *full_url, const char *save_path, HttpClientClse(&client); fclose(fd); HttpClientUnprepare(&client_data); +#if defined(SUPPORT_CAT1_SERVICE) || defined(SUPPORT_PPP_SERVICE) + cat1_api_keep_wakeup(0); +#endif return -1; } @@ -481,6 +503,9 @@ static int ln_download_file_to_path(const char *full_url, const char *save_path, if (header_buf) free(header_buf); HttpClientClse(&client); HttpClientUnprepare(&client_data); +#if defined(SUPPORT_CAT1_SERVICE) || defined(SUPPORT_PPP_SERVICE) + cat1_api_keep_wakeup(0); +#endif return -1; } resume_offset = 0; @@ -499,17 +524,35 @@ static int ln_download_file_to_path(const char *full_url, const char *save_path, fclose(fd); HttpClientClse(&client); HttpClientUnprepare(&client_data); +#if defined(SUPPORT_CAT1_SERVICE) || defined(SUPPORT_PPP_SERVICE) + cat1_api_keep_wakeup(0); +#endif return -1; } total_written += written; // 进度上报(基于 resume_offset + total_written) + // 优化:限制更新频率,避免频繁UI刷新影响下载性能 long long current_total = resume_offset + (long long)total_written; int percent = (int)((current_total * 100) / total_size); if (percent > 100) percent = 100; - if (percent != last_percent) + + // 获取当前时间(毫秒) + extern uint32_t uapi_tcxo_get_ms(void); + uint32_t current_time = uapi_tcxo_get_ms(); + + // 限制更新频率:每500ms或每2%更新一次,或达到100% + // 处理时间溢出:如果 current_time < last_progress_update_time,说明时间溢出,强制更新 + uint32_t time_delta = (current_time >= last_progress_update_time) ? + (current_time - last_progress_update_time) : + (0xFFFFFFFF - last_progress_update_time + current_time + 1); + if (percent != last_percent && + (percent == 100 || + (percent - last_percent >= PROGRESS_UPDATE_THRESHOLD) || + (time_delta >= PROGRESS_UPDATE_INTERVAL_MS))) { last_percent = percent; + last_progress_update_time = current_time; OtaDownloadMsg om = {0}; om.status = OTA_DOWNLOAD_STATUS_PROGRESS; om.progress = percent; @@ -518,8 +561,24 @@ static int ln_download_file_to_path(const char *full_url, const char *save_path, } // 后续接收循环 + // 用于定期喂狗,防止长时间下载导致看门狗超时 + extern uint32_t uapi_tcxo_get_ms(void); + uint32_t last_watchdog_kick_time = uapi_tcxo_get_ms(); + const uint32_t WATCHDOG_KICK_INTERVAL_MS = 2000; // 每2秒喂一次狗(看门狗超时8秒) + while (client_data.isMore) { + // 定期喂狗,防止长时间下载导致看门狗超时触发 NMI + uint32_t current_time = uapi_tcxo_get_ms(); + uint32_t time_since_last_kick = (current_time >= last_watchdog_kick_time) ? + (current_time - last_watchdog_kick_time) : + (0xFFFFFFFF - last_watchdog_kick_time + current_time + 1); + if (time_since_last_kick >= WATCHDOG_KICK_INTERVAL_MS) + { + uapi_watchdog_kick(); + last_watchdog_kick_time = current_time; + } + HTTPC_RESULT recv_res = HttpClientRecvResponse(&client, &client_data); if (recv_res == HTTP_SUCCESS || recv_res == HTTP_EAGAIN) { @@ -533,16 +592,36 @@ static int ln_download_file_to_path(const char *full_url, const char *save_path, fclose(fd); HttpClientClse(&client); HttpClientUnprepare(&client_data); +#if defined(SUPPORT_CAT1_SERVICE) || defined(SUPPORT_PPP_SERVICE) + cat1_api_keep_wakeup(0); + cat1_api_remove_cat1_app_vote(); +#endif return -1; } total_written += written; + // 进度上报(基于 resume_offset + total_written) + // 优化:限制更新频率,避免频繁UI刷新影响下载性能 long long current_total = resume_offset + (long long)total_written; int percent = (int)((current_total * 100) / total_size); if (percent > 100) percent = 100; - if (percent != last_percent) + + // 获取当前时间(毫秒) + extern uint32_t uapi_tcxo_get_ms(void); + uint32_t current_time = uapi_tcxo_get_ms(); + + // 限制更新频率:每500ms或每2%更新一次,或达到100% + // 处理时间溢出:如果 current_time < last_progress_update_time,说明时间溢出,强制更新 + uint32_t time_delta = (current_time >= last_progress_update_time) ? + (current_time - last_progress_update_time) : + (0xFFFFFFFF - last_progress_update_time + current_time + 1); + if (percent != last_percent && + (percent == 100 || + (percent - last_percent >= PROGRESS_UPDATE_THRESHOLD) || + (time_delta >= PROGRESS_UPDATE_INTERVAL_MS))) { last_percent = percent; + last_progress_update_time = current_time; OtaDownloadMsg om = {0}; om.status = OTA_DOWNLOAD_STATUS_PROGRESS; om.progress = percent; @@ -556,6 +635,10 @@ static int ln_download_file_to_path(const char *full_url, const char *save_path, fclose(fd); HttpClientClse(&client); HttpClientUnprepare(&client_data); +#if defined(SUPPORT_CAT1_SERVICE) || defined(SUPPORT_PPP_SERVICE) + cat1_api_keep_wakeup(0); + cat1_api_remove_cat1_app_vote(); +#endif return -1; } } @@ -593,6 +676,13 @@ static int ln_download_file_to_path(const char *full_url, const char *save_path, HttpClientClse(&client); HttpClientUnprepare(&client_data); +#if defined(SUPPORT_CAT1_SERVICE) || defined(SUPPORT_PPP_SERVICE) + /* 释放CAT1唤醒,允许休眠 */ + cat1_api_keep_wakeup(0); + /* 移除CAT1投票 */ + cat1_api_remove_cat1_app_vote(); +#endif + printf("[OTA] download process finished\n"); return ret; diff --git a/code/sdk/zhihui/leiniao/imsl_ln/ln_api_speech_chat.c b/code/sdk/zhihui/leiniao/imsl_ln/ln_api_speech_chat.c index a7d9829d0..48110792b 100644 --- a/code/sdk/zhihui/leiniao/imsl_ln/ln_api_speech_chat.c +++ b/code/sdk/zhihui/leiniao/imsl_ln/ln_api_speech_chat.c @@ -1,5 +1,8 @@ #include "ln_api.h" +#include "ln_http_download_client.h" #include +#include +#include /* 读取整个文件到内存,返回缓冲区和长度;需调用者 free */ static uint8_t *ln_read_file_all_speech_chat(const char *path, int *out_len) @@ -98,6 +101,100 @@ static void ln_parse_speech_file(void) } } +/* Header构建上下文 */ +typedef struct { + const char *device_id; + const char *device_token; +} speech_chat_header_ctx_t; + +/* Body构建上下文 */ +typedef struct { + char *body; + int body_len; + const char *content_type; +} speech_chat_body_ctx_t; + +/* 数据块处理上下文 */ +typedef struct { + FILE *file; + size_t total_written; +} speech_chat_chunk_ctx_t; + +/* Header构建回调 */ +static char* build_speech_chat_header(void *user_data) +{ + speech_chat_header_ctx_t *ctx = (speech_chat_header_ctx_t*)user_data; + if (!ctx || !ctx->device_id || !ctx->device_token) + { + return NULL; + } + + char *base_header = ln_http_build_default_header(ctx->device_id, ctx->device_token, NULL); + if (!base_header) + { + return NULL; + } + + // 追加SSE相关的header + size_t base_len = strlen(base_header); + size_t extra_len = strlen("Accept: text/event-stream\r\nCache-Control: no-cache\r\n"); + char *full_header = (char *)realloc(base_header, base_len + extra_len + 1); + if (!full_header) + { + free(base_header); + return NULL; + } + + strcat(full_header, "Accept: text/event-stream\r\n"); + strcat(full_header, "Cache-Control: no-cache\r\n"); + + printf("chatstream header_buf: %s\n", full_header); + return full_header; +} + +/* Body构建回调 */ +static char* build_speech_chat_body(void *user_data, int *body_len_out, + char *content_type_out, int content_type_size) +{ + speech_chat_body_ctx_t *ctx = (speech_chat_body_ctx_t*)user_data; + if (!ctx || !ctx->body || ctx->body_len <= 0) + { + return NULL; + } + + if (body_len_out) + { + *body_len_out = ctx->body_len; + } + + if (content_type_out && content_type_size > 0 && ctx->content_type) + { + snprintf(content_type_out, content_type_size, "%s", ctx->content_type); + } + + return ctx->body; +} + +/* 数据块处理回调 */ +static uint32_t handle_speech_chat_chunk(const char *data, int len, void *user_data) +{ + speech_chat_chunk_ctx_t *ctx = (speech_chat_chunk_ctx_t*)user_data; + if (!ctx || !ctx->file || !data || len <= 0) + { + return ERRCODE_FAIL; + } + + size_t written = fwrite(data, 1, (size_t)len, ctx->file); + if (written != (size_t)len) + { + printf("chatstream: write failed, written=%zu, expected=%d\n", written, len); + return ERRCODE_FAIL; + } + + ctx->total_written += written; + return ERRCODE_SUCC; +} + uint32_t ln_speech_chat_stream_http(const char *device_id, const char *device_token, const char *audio_path) @@ -143,129 +240,59 @@ uint32_t ln_speech_chat_stream_http(const char *device_id, } free(audio_buf); -#ifdef SUPPORT_CAT1_SERVICE - /* CAT1 保活 */ - cat1_api_add_cat1_vote(); - cat1_api_disable_cat1_cmd(0); - LOS_Msleep(500); -#endif - - HttpClient client = (HttpClient){0}; - HttpClientData clientData = (HttpClientData){0}; - - /* 自定义头:仅保留自定义业务头,Content-Type 交由 postContentType 指定 */ - char *header_buf = (char *)malloc(512); - if (!header_buf) - { - free(body); - return ERRCODE_FAIL; - } - int hdr = snprintf(header_buf, 512, - "deviceId: %s\r\n" - "deviceToken: %s\r\n" - "Accept: text/event-stream\r\n" - "Cache-Control: no-cache\r\n", - device_id, device_token); - if (hdr <= 0) - { - free(body); - free(header_buf); - return ERRCODE_FAIL; - } - HttpClientSetCustomHeader(&client, header_buf); - printf("chatstream header_buf: %s\n", header_buf); - - /* 准备缓冲区(自适应) */ - HTTPC_RESULT prep = ln_http_prepare_auto(&clientData, 2048, LN_CLIENT_PREPARE_SIZE * 2); - if (prep != HTTP_SUCCESS) - { - free(body); - return ERRCODE_FAIL; - } - - /* 设置POST数据与Content-Type(放在Prepare之后,避免被重置) */ - clientData.postBuf = body; - clientData.postBufLen = body_len; - clientData.postContentType = content_type; - /* SSE 场景:响应通常为 Transfer-Encoding: chunked,打开分块标志以避免长度校验问题 */ - clientData.isChunked = true; - - int ret = -1; - ret = HttpClientConn(&client, LN_CHAT_URL); - if (ret != 0) - { - printf("connection failed, ret=0x%x\n", ret); - free(body); - HttpClientUnprepare(&clientData); - return ret; - } - - ret = HttpClientSend(&client, LN_CHAT_URL, HTTP_POST, &clientData); - if (ret != 0) - { - printf("send request failed, ret=0x%x\n", ret); - free(body); - HttpClientClse(&client); - HttpClientUnprepare(&clientData); - return ret; - } - + /* 打开文件准备写入 */ FILE *fd = fopen(speech_file_path, "w+"); if (!fd) { printf("chatstream: fopen failed for %s:\n", speech_file_path); free(body); - HttpClientClse(&client); - HttpClientUnprepare(&clientData); return ERRCODE_FAIL; } - size_t total_written = 0; - do - { - HTTPC_RESULT recv_res = HttpClientRecvResponse(&client, &clientData); - printf("chatstream: recv response result: %d\n", recv_res); - if (recv_res == HTTP_SUCCESS || recv_res == HTTP_EAGAIN) - { - // 处理接收到的数据块 - if (clientData.contentBlockLen > 0) - { - // 写入到文件(保持原有功能) - size_t written = fwrite(clientData.responseBuf, 1, clientData.contentBlockLen, fd); - if (written != clientData.contentBlockLen) - { - printf("chatstream: write failed, written=%zu, expected=%d\n", - written, clientData.contentBlockLen); - free(body); - HttpClientClse(&client); - HttpClientUnprepare(&clientData); - fclose(fd); - return ERRCODE_FAIL; - } - total_written += written; - } - else - { - /* 无新数据块但仍需继续时,适当让出CPU降低忙等 */ - LOS_Msleep(10); - } - } - else - { - printf("chatstream: SSE receive ended (code: %d)\n", recv_res); - break; - } - } while (clientData.isMore); + /* 设置上下文 */ + speech_chat_header_ctx_t header_ctx = { + .device_id = device_id, + .device_token = device_token + }; + + speech_chat_body_ctx_t body_ctx = { + .body = body, + .body_len = body_len, + .content_type = content_type + }; + + speech_chat_chunk_ctx_t chunk_ctx = { + .file = fd, + .total_written = 0 + }; + + /* 配置流式下载请求 */ + ln_http_download_request_t req = { + .url = LN_CHAT_URL, + .method = LN_DOWNLOAD_METHOD_POST, + .is_https = true, + .header_size = 2048, + .response_size = LN_CLIENT_PREPARE_SIZE * 2, + .build_header_cb = build_speech_chat_header, + .header_user_data = &header_ctx, + .build_body_cb = build_speech_chat_body, + .body_user_data = &body_ctx, + .chunk_handler_cb = handle_speech_chat_chunk, + .user_data = &chunk_ctx, + .enable_cat1_keepalive = true, + .enable_chunked = true, + .range_header = NULL + }; - HttpClientUnprepare(&clientData); - HttpClientClse(&client); - free(body); + /* 执行流式下载 */ + uint32_t result = ln_http_download_stream(&req); + fclose(fd); - if (total_written > 0) + if (result == ERRCODE_SUCC && chunk_ctx.total_written > 0) { ln_parse_speech_file(); } - return ERRCODE_SUCC; + return result; } diff --git a/code/sdk/zhihui/leiniao/imsl_ln/ln_api_story_choose.c b/code/sdk/zhihui/leiniao/imsl_ln/ln_api_story_choose.c index 98c3a6b63..fff4bf84b 100644 --- a/code/sdk/zhihui/leiniao/imsl_ln/ln_api_story_choose.c +++ b/code/sdk/zhihui/leiniao/imsl_ln/ln_api_story_choose.c @@ -1,5 +1,8 @@ #include "ln_api.h" +#include "ln_http_download_client.h" #include +#include +#include /* 读取整个文件到内存,返回缓冲区和长度;需调用者 free */ static uint8_t *ln_read_file_all_story(const char *path, int *out_len) @@ -98,6 +101,101 @@ static void ln_parse_story_file(void) } } +/* Header构建上下文 */ +typedef struct { + const char *device_id; + const char *device_token; +} story_choose_header_ctx_t; + +/* 数据块处理上下文 */ +typedef struct { + FILE *file; + size_t total_written; +} story_choose_chunk_ctx_t; + +/* Header构建回调 */ +static char* build_story_choose_header(void *user_data) +{ + story_choose_header_ctx_t *ctx = (story_choose_header_ctx_t*)user_data; + if (!ctx || !ctx->device_id || !ctx->device_token) + { + return NULL; + } + + char *base_header = ln_http_build_default_header(ctx->device_id, ctx->device_token, NULL); + if (!base_header) + { + return NULL; + } + + // 追加SSE相关的header + size_t base_len = strlen(base_header); + size_t extra_len = strlen("Accept: text/event-stream\r\nCache-Control: no-cache\r\n"); + char *full_header = (char *)realloc(base_header, base_len + extra_len + 1); + if (!full_header) + { + free(base_header); + return NULL; + } + + strcat(full_header, "Accept: text/event-stream\r\n"); + strcat(full_header, "Cache-Control: no-cache\r\n"); + + printf("story choose header_buf: %s\n", full_header); + return full_header; +} + +/* Body构建上下文 */ +typedef struct { + char *body; + int body_len; + const char *content_type; +} story_choose_body_ctx_t; + +/* Body构建回调 */ +static char* build_story_choose_body(void *user_data, int *body_len_out, + char *content_type_out, int content_type_size) +{ + story_choose_body_ctx_t *ctx = (story_choose_body_ctx_t*)user_data; + if (!ctx || !ctx->body || ctx->body_len <= 0) + { + return NULL; + } + + if (body_len_out) + { + *body_len_out = ctx->body_len; + } + + if (content_type_out && content_type_size > 0 && ctx->content_type) + { + snprintf(content_type_out, content_type_size, "%s", ctx->content_type); + } + + // 返回body,统一接口会负责释放 + return ctx->body; +} + +/* 数据块处理回调 */ +static uint32_t handle_story_choose_chunk(const char *data, int len, void *user_data) +{ + story_choose_chunk_ctx_t *ctx = (story_choose_chunk_ctx_t*)user_data; + if (!ctx || !ctx->file || !data || len <= 0) + { + return ERRCODE_FAIL; + } + + size_t written = fwrite(data, 1, (size_t)len, ctx->file); + if (written != (size_t)len) + { + printf("story choose: write failed, written=%zu, expected=%d\n", written, len); + return ERRCODE_FAIL; + } + + ctx->total_written += written; + return ERRCODE_SUCC; +} + uint32_t ln_story_choose_http(const char *device_id, const char *device_token, const char *audio_path) @@ -140,129 +238,61 @@ uint32_t ln_story_choose_http(const char *device_id, } free(audio_buf); -#ifdef SUPPORT_CAT1_SERVICE - /* CAT1 网络保活处理 */ - cat1_api_add_cat1_vote(); - cat1_api_disable_cat1_cmd(0); - LOS_Msleep(500); -#endif - - HttpClient client = {0}; - HttpClientData clientData = {0}; - - /* 设置请求头:精简头部,避免重复(Host/Connection 交由库设置) */ - char *header_buf = (char *)malloc(1024); - if (!header_buf) - { - free(body); - return ERRCODE_FAIL; - } - int hdr = snprintf(header_buf, 1024, - "deviceId: %s\r\n" - "deviceToken: %s\r\n" - "Accept: text/event-stream\r\n" - "Cache-Control: no-cache\r\n", - device_id, device_token); - if (hdr <= 0) - { - printf("story choose: build header failed\n"); - free(body); - free(header_buf); - return ERRCODE_FAIL; - } - HttpClientSetCustomHeader(&client, header_buf); - printf("story choose header_buf: %s\n", header_buf); - - /* 自适应准备 HTTP 缓冲区 */ - HTTPC_RESULT prep = ln_http_prepare_auto(&clientData, 2048, LN_CLIENT_PREPARE_SIZE * 2); - if (prep != HTTP_SUCCESS) - { - printf("story choose: prepare HTTP buffer failed (code: %d)\n", prep); - free(body); - return ERRCODE_FAIL; - } - - /* 设置 POST 数据 */ - clientData.postBuf = body; - clientData.postBufLen = body_len; - clientData.postContentType = content_type; - clientData.isChunked = true; - - int ret = -1; - ret = HttpClientConn(&client, LN_STORY_CHOOSE_URL); - if (ret != 0) - { - printf("connection failed, ret=0x%x\n", ret); - free(body); - HttpClientUnprepare(&clientData); - return ret; - } - - ret = HttpClientSend(&client, LN_STORY_CHOOSE_URL, HTTP_POST, &clientData); - if (ret != 0) - { - printf("send request failed, ret=0x%x\n", ret); - free(body); - HttpClientClse(&client); - HttpClientUnprepare(&clientData); - return ret; - } - + /* 打开文件准备写入 */ FILE *fd = fopen(story_choose_file_path, "w+"); if (!fd) { printf("story choose: fopen failed for %s:\n", story_choose_file_path); free(body); - HttpClientClse(&client); - HttpClientUnprepare(&clientData); return ERRCODE_FAIL; } - size_t total_written = 0; - do - { - HTTPC_RESULT recv_res = HttpClientRecvResponse(&client, &clientData); - printf("story choose: recv response result: %d\n", recv_res); - if (recv_res == HTTP_SUCCESS || recv_res == HTTP_EAGAIN) - { - // 处理接收到的数据块 - if (clientData.contentBlockLen > 0) - { - size_t written = fwrite(clientData.responseBuf, 1, clientData.contentBlockLen, fd); - if (written != clientData.contentBlockLen) - { - printf("story choose: write failed, written=%zu, expected=%d\n", - written, clientData.contentBlockLen); - free(body); - HttpClientClse(&client); - HttpClientUnprepare(&clientData); - fclose(fd); - return ERRCODE_FAIL; - } - total_written += written; - } - else - { - /* 无新数据块但仍需继续时,适当让出CPU降低忙等 */ - LOS_Msleep(10); - } - } - else - { - printf("story choose: SSE receive ended (code: %d)\n", recv_res); - break; - } - } while (clientData.isMore); + /* 设置上下文 */ + story_choose_header_ctx_t header_ctx = { + .device_id = device_id, + .device_token = device_token + }; + + story_choose_body_ctx_t body_ctx = { + .body = body, + .body_len = body_len, + .content_type = content_type + }; + + story_choose_chunk_ctx_t chunk_ctx = { + .file = fd, + .total_written = 0 + }; + + /* 配置流式下载请求 */ + ln_http_download_request_t req = { + .url = LN_STORY_CHOOSE_URL, + .method = LN_DOWNLOAD_METHOD_POST, + .is_https = true, + .header_size = 2048, + .response_size = LN_CLIENT_PREPARE_SIZE * 2, + .build_header_cb = build_story_choose_header, + .header_user_data = &header_ctx, + .build_body_cb = build_story_choose_body, + .body_user_data = &body_ctx, + .chunk_handler_cb = handle_story_choose_chunk, + .user_data = &chunk_ctx, + .enable_cat1_keepalive = true, + .enable_chunked = true, + .range_header = NULL + }; - free(body); - HttpClientUnprepare(&clientData); - HttpClientClse(&client); + /* 执行流式下载 */ + uint32_t result = ln_http_download_stream(&req); + fclose(fd); - if (total_written > 0) + if (result == ERRCODE_SUCC && chunk_ctx.total_written > 0) { ln_parse_story_file(); } - return ERRCODE_SUCC; + // body会在统一接口中自动释放,这里不需要手动释放 + + return result; } diff --git a/code/sdk/zhihui/leiniao/imsl_ln/ln_api_story_exit.c b/code/sdk/zhihui/leiniao/imsl_ln/ln_api_story_exit.c index 483e203d9..1b32e2139 100644 --- a/code/sdk/zhihui/leiniao/imsl_ln/ln_api_story_exit.c +++ b/code/sdk/zhihui/leiniao/imsl_ln/ln_api_story_exit.c @@ -1,71 +1,82 @@ #include "ln_api.h" +#include "ln_http_client.h" #include +#include +#include -uint32_t ln_story_exit_inquiry_http(const char *device_id, - const char *device_token) -{ - if (!device_id || !device_token) - return ERRCODE_FAIL; -#ifdef SUPPORT_CAT1_SERVICE - /* CAT1 保活 */ - cat1_api_add_cat1_vote(); - cat1_api_disable_cat1_cmd(0); - LOS_Msleep(200); -#endif - - HttpClient client = (HttpClient){0}; - HttpClientData clientData = (HttpClientData){0}; - client.isHttp = false; - client.remotePort = 443; +/* Header构建上下文 */ +typedef struct { + const char *device_id; + const char *device_token; +} story_exit_header_ctx_t; - /* 普通JSON头 */ - char *header_buf = (char *)malloc(512); - if (!header_buf) - return ERRCODE_FAIL; - int hdr = snprintf(header_buf, 512, - "deviceId: %s\r\ndeviceToken: %s\r\nContent-Type: application/json\r\n", - device_id, device_token); - printf("ln_story_finish_http header_buf: %s\n", header_buf); - if (hdr <= 0) - { - free(header_buf); - return ERRCODE_FAIL; +/* Header构建回调 */ +static char* build_story_exit_header(void *user_data) +{ + story_exit_header_ctx_t *ctx = (story_exit_header_ctx_t*)user_data; + char *header = ln_http_build_default_header(ctx->device_id, ctx->device_token, NULL); + if (header) { + printf("ln_story_exit_http header_buf: %s\n", header); } - HttpClientSetCustomHeader(&client, header_buf); - - HTTPC_RESULT prep = ln_http_prepare_auto(&clientData, 2048, 8 * 1024); - if (prep != HTTP_SUCCESS) - return ERRCODE_FAIL; - - clientData.postBuf = (char *)"{}"; - clientData.postBufLen = 2; - clientData.postContentType = (char *)"application/json"; + return header; +} - HTTPC_RESULT res = HttpClientPostRequest(&client, LN_STORY_EXIT_INQUIRY_URL, &clientData); - if (res != HTTP_SUCCESS) - { - printf("story exit inquiry post failed %d\n", res); - goto end; +/* Body构建回调(空JSON对象) */ +static char* build_story_exit_body(void *user_data, int *body_len_out, + char *content_type_out, int content_type_size) +{ + if (content_type_out && content_type_size > 0) { + snprintf(content_type_out, content_type_size, "application/json"); } - if (HttpClientGetResponseCode(&client) != 200) - { - printf("story exit inquiry HTTP %d\n", HttpClientGetResponseCode(&client)); - if (clientData.responseBuf && clientData.responseBufLen > 0) - { - int real_len = clientData.responseContentLen > 0 ? clientData.responseContentLen : clientData.responseBufLen; + + // 分配并返回动态字符串,统一接口会负责释放 + char *body = (char *)malloc(3); + if (body) { + strcpy(body, "{}"); + if (body_len_out) { + *body_len_out = 2; } - goto end; } + return body; +} - if (clientData.responseBuf && clientData.responseBufLen > 0) +/* 响应处理回调 */ +static uint32_t handle_story_exit_response(const char *response_data, int response_len, + int status_code, void *user_data) +{ + if (status_code != 200) { - int real_len = clientData.responseContentLen > 0 ? clientData.responseContentLen : clientData.responseBufLen; + printf("story exit inquiry HTTP %d\n", status_code); + return ERRCODE_FAIL; } -end: - HttpClientUnprepare(&clientData); - HttpClientClse(&client); - if (header_buf) - free(header_buf); + // 当前不需要处理响应数据,只需要检查状态码 return ERRCODE_SUCC; } + +uint32_t ln_story_exit_inquiry_http(const char *device_id, + const char *device_token) +{ + if (!device_id || !device_token) + return ERRCODE_FAIL; + + story_exit_header_ctx_t header_ctx = { + .device_id = device_id, + .device_token = device_token + }; + + ln_http_request_t req = { + .url = LN_STORY_EXIT_INQUIRY_URL, + .method = LN_HTTP_METHOD_POST, + .is_https = true, + .header_size = 2048, + .response_size = 8 * 1024, + .build_header_cb = build_story_exit_header, + .build_body_cb = build_story_exit_body, + .response_handler_cb = handle_story_exit_response, + .user_data = &header_ctx, + .enable_cat1_keepalive = true + }; + + return ln_http_client_request(&req); +} diff --git a/code/sdk/zhihui/leiniao/imsl_ln/ln_api_story_finish.c b/code/sdk/zhihui/leiniao/imsl_ln/ln_api_story_finish.c index 7c9a79c75..d78e32335 100644 --- a/code/sdk/zhihui/leiniao/imsl_ln/ln_api_story_finish.c +++ b/code/sdk/zhihui/leiniao/imsl_ln/ln_api_story_finish.c @@ -1,69 +1,78 @@ #include "ln_api.h" +#include "ln_http_client.h" #include +#include +#include -uint32_t ln_story_finish_http(const char *device_id, - const char *device_token) -{ - if (!device_id || !device_token) - return ERRCODE_FAIL; +/* Header构建上下文 */ +typedef struct { + const char *device_id; + const char *device_token; +} story_finish_header_ctx_t; -#ifdef SUPPORT_CAT1_SERVICE - /* CAT1 保活 */ - cat1_api_add_cat1_vote(); - cat1_api_disable_cat1_cmd(0); - LOS_Msleep(200); -#endif +/* Header构建回调 */ +static char* build_story_finish_header(void *user_data) +{ + story_finish_header_ctx_t *ctx = (story_finish_header_ctx_t*)user_data; + return ln_http_build_default_header(ctx->device_id, ctx->device_token, NULL); +} - HttpClient client = (HttpClient){0}; - HttpClientData clientData = (HttpClientData){0}; - client.isHttp = false; - client.remotePort = 443; +/* Body构建回调(空JSON对象) */ +static char* build_story_finish_body(void *user_data, int *body_len_out, + char *content_type_out, int content_type_size) +{ + if (content_type_out && content_type_size > 0) { + snprintf(content_type_out, content_type_size, "application/json"); + } + + // 分配并返回动态字符串,统一接口会负责释放 + char *body = (char *)malloc(3); + if (body) { + strcpy(body, "{}"); + if (body_len_out) { + *body_len_out = 2; + } + } + return body; +} - char *header_buf = (char *)malloc(512); - if (!header_buf) - return ERRCODE_FAIL; - int hdr = snprintf(header_buf, 512, - "deviceId: %s\r\ndeviceToken: %s\r\nContent-Type: application/json\r\n", - device_id, device_token); - if (hdr <= 0) +/* 响应处理回调 */ +static uint32_t handle_story_finish_response(const char *response_data, int response_len, + int status_code, void *user_data) +{ + if (status_code != 200) { + printf("story finish HTTP %d\n", status_code); return ERRCODE_FAIL; } - HttpClientSetCustomHeader(&client, header_buf); - HTTPC_RESULT prep = ln_http_prepare_auto(&clientData, 2048, 8 * 1024); - if (prep != HTTP_SUCCESS) - return ERRCODE_FAIL; + // 当前不需要处理响应数据,只需要检查状态码 + return ERRCODE_SUCC; +} - clientData.postBuf = (char *)"{}"; - clientData.postBufLen = 2; - clientData.postContentType = (char *)"application/json"; +uint32_t ln_story_finish_http(const char *device_id, + const char *device_token) +{ + if (!device_id || !device_token) + return ERRCODE_FAIL; - HTTPC_RESULT res = HttpClientPostRequest(&client, LN_STORY_FINISH_URL, &clientData); - if (res != HTTP_SUCCESS) - { - printf("story finish post failed %d\n", res); - goto end; - } - int code = HttpClientGetResponseCode(&client); - if (code != 200) - { - printf("device getUserId: HTTP %d\n", code); - if (clientData.responseBuf && clientData.responseBufLen > 0) - { - int real_len = clientData.responseContentLen > 0 ? clientData.responseContentLen : clientData.responseBufLen; - } - goto end; - } + story_finish_header_ctx_t header_ctx = { + .device_id = device_id, + .device_token = device_token + }; - if (clientData.responseBuf && clientData.responseBufLen > 0) - { - int real_len = clientData.responseContentLen > 0 ? clientData.responseContentLen : clientData.responseBufLen; - } + ln_http_request_t req = { + .url = LN_STORY_FINISH_URL, + .method = LN_HTTP_METHOD_POST, + .is_https = true, + .header_size = 2048, + .response_size = 8 * 1024, + .build_header_cb = build_story_finish_header, + .build_body_cb = build_story_finish_body, + .response_handler_cb = handle_story_finish_response, + .user_data = &header_ctx, + .enable_cat1_keepalive = true + }; -end: - HttpClientUnprepare(&clientData); - HttpClientClse(&client); - free(header_buf); - return ERRCODE_SUCC; + return ln_http_client_request(&req); } diff --git a/code/sdk/zhihui/leiniao/imsl_ln/ln_api_story_random.c b/code/sdk/zhihui/leiniao/imsl_ln/ln_api_story_random.c index 727f93def..0d900dd29 100644 --- a/code/sdk/zhihui/leiniao/imsl_ln/ln_api_story_random.c +++ b/code/sdk/zhihui/leiniao/imsl_ln/ln_api_story_random.c @@ -1,6 +1,8 @@ #include "ln_api.h" +#include "ln_http_download_client.h" #include #include +#include #include "cJSON.h" static void ln_parse_story_random_file(void) @@ -19,50 +21,103 @@ static void ln_parse_story_random_file(void) } } -uint32_t ln_story_random_http(const char *device_id, - const char *device_token, - const char *story_theme) +/* Header构建上下文 */ +typedef struct { + const char *device_id; + const char *device_token; +} story_random_header_ctx_t; + +/* Body构建上下文 */ +typedef struct { + char *body; + int body_len; +} story_random_body_ctx_t; + +/* 数据块处理上下文 */ +typedef struct { + FILE *file; + size_t total_written; +} story_random_chunk_ctx_t; + +/* Header构建回调 */ +static char* build_story_random_header(void *user_data) { - if (!device_id || !device_token) + story_random_header_ctx_t *ctx = (story_random_header_ctx_t*)user_data; + if (!ctx || !ctx->device_id || !ctx->device_token) { - printf("story random: invalid parameters\n"); - return ERRCODE_FAIL; + return NULL; } + + char *base_header = ln_http_build_default_header(ctx->device_id, ctx->device_token, NULL); + if (!base_header) + { + return NULL; + } + + // 追加Content-Type + size_t base_len = strlen(base_header); + size_t extra_len = strlen("Content-Type: application/json\r\n"); + char *full_header = (char *)realloc(base_header, base_len + extra_len + 1); + if (!full_header) + { + free(base_header); + return NULL; + } + + strcat(full_header, "Content-Type: application/json\r\n"); + return full_header; +} -#ifdef SUPPORT_CAT1_SERVICE - /* CAT1 网络保活处理 */ - cat1_api_add_cat1_vote(); - cat1_api_disable_cat1_cmd(0); - LOS_Msleep(500); -#endif - - HttpClient client = {0}; - HttpClientData clientData = {0}; - client.isHttp = false; // 使用 HTTPS - client.remotePort = 443; +/* Body构建回调 */ +static char* build_story_random_body(void *user_data, int *body_len_out, + char *content_type_out, int content_type_size) +{ + story_random_body_ctx_t *ctx = (story_random_body_ctx_t*)user_data; + if (!ctx || !ctx->body || ctx->body_len <= 0) + { + return NULL; + } + + if (body_len_out) + { + *body_len_out = ctx->body_len; + } + + if (content_type_out && content_type_size > 0) + { + snprintf(content_type_out, content_type_size, "application/json"); + } + + return ctx->body; +} - /* 设置请求头(包含Content-Type,保持与Python一致) */ - char *header_buf = (char *)malloc(1024); - if (!header_buf) +/* 数据块处理回调 */ +static uint32_t handle_story_random_chunk(const char *data, int len, void *user_data) +{ + story_random_chunk_ctx_t *ctx = (story_random_chunk_ctx_t*)user_data; + if (!ctx || !ctx->file || !data || len <= 0) + { return ERRCODE_FAIL; - int hdr = snprintf(header_buf, 1024, - "deviceId: %s\r\n" - "deviceToken: %s\r\n" - "Content-Type: application/json\r\n", - device_id, device_token); - if (hdr <= 0) + } + + size_t written = fwrite(data, 1, (size_t)len, ctx->file); + if (written != (size_t)len) { - free(header_buf); + printf("story random: write failed, written=%zu, expected=%d\n", written, len); return ERRCODE_FAIL; } - HttpClientSetCustomHeader(&client, header_buf); + + ctx->total_written += written; + return ERRCODE_SUCC; +} - /* 自适应准备 HTTP 缓冲区 */ - HTTPC_RESULT prep = ln_http_prepare_auto(&clientData, 2048, LN_CLIENT_PREPARE_SIZE * 2); - if (prep != HTTP_SUCCESS) +uint32_t ln_story_random_http(const char *device_id, + const char *device_token, + const char *story_theme) +{ + if (!device_id || !device_token) { - printf("story random: prepare HTTP buffer failed (code: %d)\n", prep); - free(header_buf); + printf("story random: invalid parameters\n"); return ERRCODE_FAIL; } @@ -75,7 +130,6 @@ uint32_t ln_story_random_http(const char *device_id, free(json_body); if (escaped_theme) free(escaped_theme); - free(header_buf); return ERRCODE_FAIL; } int json_len = 0; @@ -99,104 +153,66 @@ uint32_t ln_story_random_http(const char *device_id, } if (json_len <= 0) { - free(header_buf); free(json_body); free(escaped_theme); return ERRCODE_FAIL; } + free(escaped_theme); - /* 设置 POST 数据 */ - clientData.postBuf = json_body; - clientData.postBufLen = json_len; - clientData.postContentType = (char *)"application/json"; - - int ret = -1; - ret = HttpClientConn(&client, LN_STORY_RANDOM_URL); - if (ret != 0) - { - printf("[OTA] connection failed, ret=0x%x\n", ret); - free(header_buf); - free(json_body); - free(escaped_theme); - HttpClientUnprepare(&clientData); - return ret; - } - - // 发送GET请求 - ret = HttpClientSend(&client, LN_STORY_RANDOM_URL, HTTP_POST, &clientData); - if (ret != 0) - { - printf("[OTA] send request failed, ret=0x%x\n", ret); - HttpClientClse(&client); - HttpClientUnprepare(&clientData); - free(header_buf); - free(json_body); - free(escaped_theme); - return ret; - } - + /* 打开文件准备写入 */ FILE *fd = fopen(story_random_file_path, "w+"); if (!fd) { - printf("story choose: fopen failed for %s:\n", story_random_file_path); - HttpClientClse(&client); - HttpClientUnprepare(&clientData); - free(header_buf); + printf("story random: fopen failed for %s:\n", story_random_file_path); free(json_body); - free(escaped_theme); return ERRCODE_FAIL; } - size_t total_written = 0; - do - { - HTTPC_RESULT recv_res = HttpClientRecvResponse(&client, &clientData); - printf("story random: recv response result: %d\n", recv_res); - if (recv_res == HTTP_SUCCESS || recv_res == HTTP_EAGAIN) - { - // 处理接收到的数据块 - if (clientData.contentBlockLen > 0) - { - size_t written = fwrite(clientData.responseBuf, 1, clientData.contentBlockLen, fd); - if (written != clientData.contentBlockLen) - { - printf("story random: write failed, written=%zu, expected=%d\n", - written, clientData.contentBlockLen); - HttpClientClse(&client); - HttpClientUnprepare(&clientData); - fclose(fd); - free(header_buf); - free(json_body); - free(escaped_theme); - return ERRCODE_FAIL; - } - total_written += written; - } - else - { - /* 无新数据块但仍需继续时,适当让出CPU降低忙等 */ - LOS_Msleep(10); - } - } - else - { - printf("story random: SSE receive ended (code: %d)\n", recv_res); - break; - } - } while (clientData.isMore); + /* 设置上下文 */ + story_random_header_ctx_t header_ctx = { + .device_id = device_id, + .device_token = device_token + }; + + story_random_body_ctx_t body_ctx = { + .body = json_body, + .body_len = json_len + }; + + story_random_chunk_ctx_t chunk_ctx = { + .file = fd, + .total_written = 0 + }; - HttpClientUnprepare(&clientData); - HttpClientClse(&client); + /* 配置流式下载请求 */ + ln_http_download_request_t req = { + .url = LN_STORY_RANDOM_URL, + .method = LN_DOWNLOAD_METHOD_POST, + .is_https = true, + .header_size = 2048, + .response_size = LN_CLIENT_PREPARE_SIZE * 2, + .build_header_cb = build_story_random_header, + .header_user_data = &header_ctx, + .build_body_cb = build_story_random_body, + .body_user_data = &body_ctx, + .chunk_handler_cb = handle_story_random_chunk, + .user_data = &chunk_ctx, + .enable_cat1_keepalive = true, + .enable_chunked = true, + .range_header = NULL + }; - if (total_written > 0) + /* 执行流式下载 */ + uint32_t result = ln_http_download_stream(&req); + + fclose(fd); + + if (result == ERRCODE_SUCC && chunk_ctx.total_written > 0) { ln_parse_story_random_file(); } - free(header_buf); - free(json_body); - free(escaped_theme); - return ERRCODE_SUCC; + return result; } //解析语音聊天响应 diff --git a/code/sdk/zhihui/leiniao/imsl_ln/ln_api_timeline_activities.c b/code/sdk/zhihui/leiniao/imsl_ln/ln_api_timeline_activities.c index d6b125be2..722c61790 100644 --- a/code/sdk/zhihui/leiniao/imsl_ln/ln_api_timeline_activities.c +++ b/code/sdk/zhihui/leiniao/imsl_ln/ln_api_timeline_activities.c @@ -1,4 +1,5 @@ #include "ln_api.h" +#include "ln_http_client.h" #include #include #include @@ -54,74 +55,60 @@ static void ln_parse_timeline_status_and_notify(const char *json_buf, int json_l cJSON_Delete(root); } -/* 时间线状态查询(GET)*/ -uint32_t ln_timeline_get_status_http(const char *device_id, - const char *device_token) +/* 响应处理回调 */ +static uint32_t handle_timeline_response(const char *response_data, int response_len, + int status_code, void *user_data) { - if (!device_id || !device_token) - return ERRCODE_FAIL; - -#ifdef SUPPORT_CAT1_SERVICE - cat1_api_add_cat1_vote(); - cat1_api_disable_cat1_cmd(0); - LOS_Msleep(200); -#endif - uapi_pm_add_sleep_veto(PM_ID_DEBUG); - - HttpClient client = (HttpClient){0}; - HttpClientData clientData = (HttpClientData){0}; - client.isHttp = false; - client.remotePort = 443; - - char *header_buf = (char *)malloc(512); - if (!header_buf) + if (status_code != 200) { - uapi_pm_remove_sleep_veto(PM_ID_DEBUG); return ERRCODE_FAIL; } - int hdr = snprintf(header_buf, 512, - "deviceId: %s\r\n" - "deviceToken: %s\r\n" - "Content-Type: application/json\r\n", - device_id, device_token); - if (hdr <= 0) + if (response_data && response_len > 0) { - free(header_buf); - uapi_pm_remove_sleep_veto(PM_ID_DEBUG); - return ERRCODE_FAIL; + ln_parse_timeline_status_and_notify(response_data, response_len); + return ERRCODE_SUCC; } - HttpClientSetCustomHeader(&client, header_buf); + return ERRCODE_FAIL; +} - HTTPC_RESULT prep = ln_http_prepare_auto(&clientData, 2048, LN_CLIENT_PREPARE_SIZE*2); - if (prep != HTTP_SUCCESS) - { - free(header_buf); - uapi_pm_remove_sleep_veto(PM_ID_DEBUG); +/* Header构建上下文 */ +typedef struct { + const char *device_id; + const char *device_token; +} timeline_header_ctx_t; + +/* Header构建回调 */ +static char* build_timeline_header(void *user_data) +{ + timeline_header_ctx_t *ctx = (timeline_header_ctx_t*)user_data; + return ln_http_build_default_header(ctx->device_id, ctx->device_token, NULL); +} + +/* 时间线状态查询(GET)- 使用统一HTTP接口 */ +uint32_t ln_timeline_get_status_http(const char *device_id, + const char *device_token) +{ + if (!device_id || !device_token) return ERRCODE_FAIL; - } - HTTPC_RESULT res = HttpClientGetRequest(&client, LN_TIMELINE_GET_STATUS_URL, &clientData); - if (res != HTTP_SUCCESS) - { - goto end; - } - int code = HttpClientGetResponseCode(&client); - if (code != 200) - { - goto end; - } - if (clientData.responseBuf && clientData.responseBufLen > 0) - { - int real_len = clientData.responseContentLen > 0 ? clientData.responseContentLen : clientData.responseBufLen; - ln_parse_timeline_status_and_notify(clientData.responseBuf, real_len); - } + timeline_header_ctx_t header_ctx = { + .device_id = device_id, + .device_token = device_token + }; + + ln_http_request_t req = { + .url = LN_TIMELINE_GET_STATUS_URL, + .method = LN_HTTP_METHOD_GET, + .is_https = true, + .header_size = 2048, + .response_size = LN_CLIENT_PREPARE_SIZE * 2, + .build_header_cb = build_timeline_header, + .response_handler_cb = handle_timeline_response, + .user_data = &header_ctx, + .enable_cat1_keepalive = true + }; -end: - HttpClientUnprepare(&clientData); - HttpClientClse(&client); - free(header_buf); - uapi_pm_remove_sleep_veto(PM_ID_DEBUG); - return ERRCODE_SUCC; + return ln_http_client_request(&req); } diff --git a/code/sdk/zhihui/leiniao/imsl_ln/ln_api_token.c b/code/sdk/zhihui/leiniao/imsl_ln/ln_api_token.c index 898b9526d..a1a444ae7 100644 --- a/code/sdk/zhihui/leiniao/imsl_ln/ln_api_token.c +++ b/code/sdk/zhihui/leiniao/imsl_ln/ln_api_token.c @@ -1,4 +1,5 @@ #include "ln_api.h" +#include "ln_http_client.h" #include #include #include @@ -223,15 +224,22 @@ static void ln_gen_nonce(char *out, size_t len) out[len - 1] = '\0'; } -uint32_t ln_get_device_token_http(const char *device_id, - const char *device_iccid, - const char *device_model, - const char *device_version) +/* Header构建上下文 */ +typedef struct { + const char *device_id; + const char *device_iccid; + const char *device_model; + const char *device_version; + char *sign_data; // 需要释放 +} token_header_ctx_t; + +/* Header构建回调(带HMAC签名) */ +static char* build_token_header(void *user_data) { - if (device_id == NULL || device_iccid == NULL) + token_header_ctx_t *ctx = (token_header_ctx_t*)user_data; + if (!ctx || !ctx->device_id || !ctx->device_iccid) { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ln_get_device_token_http: invalid parameters,device_id=%s,device_iccid=%s", device_id, device_iccid); - return ERRCODE_FAIL; + return NULL; } /* 1. 生成时间戳(ms)与nonce */ @@ -244,24 +252,29 @@ uint32_t ln_get_device_token_http(const char *device_id, ln_gen_nonce(nonce, sizeof(nonce)); /* 2. 计算签名: deviceId:deviceIccid:timestamp:nonce */ - size_t sd_cap = strlen(device_id) + strlen(device_iccid) + strlen(timestamp) + strlen(nonce) + 4 + 1; - char *sign_data = (char *)malloc(sd_cap); - if (!sign_data) - return ERRCODE_FAIL; - (void)snprintf(sign_data, sd_cap, "%s:%s:%s:%s", device_id, device_iccid, timestamp, nonce); + size_t sd_cap = strlen(ctx->device_id) + strlen(ctx->device_iccid) + strlen(timestamp) + strlen(nonce) + 4 + 1; + ctx->sign_data = (char *)malloc(sd_cap); + if (!ctx->sign_data) + { + return NULL; + } + (void)snprintf(ctx->sign_data, sd_cap, "%s:%s:%s:%s", ctx->device_id, ctx->device_iccid, timestamp, nonce); char signature[65] = {0}; - if (ln_hmac_sha256_hex(LN_SIGN_SECRET, sign_data, signature, sizeof(signature)) != 0) + if (ln_hmac_sha256_hex(LN_SIGN_SECRET, ctx->sign_data, signature, sizeof(signature)) != 0) { WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ln_get_device_token_http: hmac calc failed"); - return ERRCODE_FAIL; + free(ctx->sign_data); + ctx->sign_data = NULL; + return NULL; } /* 3. 组织自定义请求头 */ char *header_buf = (char *)malloc(1024); if (!header_buf) { - free(sign_data); - return ERRCODE_FAIL; + free(ctx->sign_data); + ctx->sign_data = NULL; + return NULL; } int hdr_len = snprintf(header_buf, 1024, "deviceId: %s\r\n" @@ -272,91 +285,50 @@ uint32_t ln_get_device_token_http(const char *device_id, "deviceModel: %s\r\n" "deviceVersion: %s\r\n" "Content-Type: application/json\r\n", - device_id, device_iccid, timestamp, nonce, signature, - (device_model && device_model[0]) ? device_model : "AB101", - (device_version && device_version[0]) ? device_version : "1.0.0"); + ctx->device_id, ctx->device_iccid, timestamp, nonce, signature, + (ctx->device_model && ctx->device_model[0]) ? ctx->device_model : "AB101", + (ctx->device_version && ctx->device_version[0]) ? ctx->device_version : "1.0.0"); if (hdr_len <= 0) { WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ln_get_device_token_http: header build failed"); - free(sign_data); free(header_buf); - return ERRCODE_FAIL; + free(ctx->sign_data); + ctx->sign_data = NULL; + return NULL; } -#ifdef SUPPORT_CAT1_SERVICE - /* 4. 保活CAT1,准备网络 */ - cat1_api_add_cat1_vote(); - cat1_api_disable_cat1_cmd(0); - LOS_Msleep(500); -#endif - uapi_pm_add_sleep_veto(PM_ID_DEBUG); - - /* 5. 发起HTTPS GET */ - HttpClient client = (HttpClient){0}; - HttpClientData clientData = (HttpClientData){0}; - HttpClientSetCustomHeader(&client, header_buf); - - HTTPC_RESULT prep = HttpClientPrepare(&clientData, 2048, 4096); - if (prep != HTTP_SUCCESS) - { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ln_get_device_token_http: HttpClientPrepare failed %d", prep); - free(sign_data); - free(header_buf); - uapi_pm_remove_sleep_veto(PM_ID_DEBUG); - return ERRCODE_FAIL; - } + return header_buf; +} - HTTPC_RESULT res = HttpClientGetRequest(&client, LN_FULL_URL, &clientData); - if (res != HTTP_SUCCESS) - { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ln_get_device_token_http: request failed %d", res); - HttpClientUnprepare(&clientData); - HttpClientClse(&client); - free(sign_data); - free(header_buf); - uapi_pm_remove_sleep_veto(PM_ID_DEBUG); - return ERRCODE_FAIL; - } +/* 响应处理回调 */ +static uint32_t handle_token_response(const char *response_data, int response_len, + int status_code, void *user_data) +{ + token_header_ctx_t *ctx = (token_header_ctx_t*)user_data; - int code = HttpClientGetResponseCode(&client); - if (code != 200) + if (status_code != 200) { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ln_get_device_token_http: HTTP %d", code); - HttpClientUnprepare(&clientData); - HttpClientClse(&client); - free(sign_data); - free(header_buf); - uapi_pm_remove_sleep_veto(PM_ID_DEBUG); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ln_get_device_token_http: HTTP %d", status_code); return ERRCODE_FAIL; } - /* 6. 解析响应JSON */ - if (clientData.responseBuf == NULL || clientData.responseBufLen <= 0) + /* 解析响应JSON */ + if (response_data == NULL || response_len <= 0) { WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ln_get_device_token_http: empty body"); - HttpClientUnprepare(&clientData); - HttpClientClse(&client); - free(sign_data); - free(header_buf); - uapi_pm_remove_sleep_veto(PM_ID_DEBUG); return ERRCODE_FAIL; } - int body_len = clientData.responseContentLen > 0 ? clientData.responseContentLen : clientData.responseBufLen; + int body_len = response_len; if (body_len <= 0) - body_len = (int)strlen(clientData.responseBuf); + body_len = (int)strlen(response_data); char *json_text = (char *)malloc((size_t)body_len + 1); if (json_text == NULL) { - HttpClientUnprepare(&clientData); - HttpClientClse(&client); - free(sign_data); - free(header_buf); - uapi_pm_remove_sleep_veto(PM_ID_DEBUG); return ERRCODE_FAIL; } - memcpy(json_text, clientData.responseBuf, (size_t)body_len); + memcpy(json_text, response_data, (size_t)body_len); json_text[body_len] = '\0'; cJSON *root = cJSON_Parse(json_text); @@ -364,11 +336,6 @@ uint32_t ln_get_device_token_http(const char *device_id, { WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ln_get_device_token_http: JSON parse failed"); free(json_text); - HttpClientUnprepare(&clientData); - HttpClientClse(&client); - free(sign_data); - free(header_buf); - uapi_pm_remove_sleep_veto(PM_ID_DEBUG); return ERRCODE_FAIL; } @@ -381,9 +348,6 @@ uint32_t ln_get_device_token_http(const char *device_id, WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ln_get_device_token_http: failed, message=%s", msg && cJSON_IsString(msg) ? msg->valuestring : "unknown"); cJSON_Delete(root); free(json_text); - HttpClientUnprepare(&clientData); - HttpClientClse(&client); - uapi_pm_remove_sleep_veto(PM_ID_DEBUG); return ERRCODE_FAIL; } @@ -425,10 +389,47 @@ uint32_t ln_get_device_token_http(const char *device_id, cJSON_Delete(root); free(json_text); - HttpClientUnprepare(&clientData); - HttpClientClse(&client); - free(sign_data); - free(header_buf); - uapi_pm_remove_sleep_veto(PM_ID_DEBUG); return ERRCODE_SUCC; } + +uint32_t ln_get_device_token_http(const char *device_id, + const char *device_iccid, + const char *device_model, + const char *device_version) +{ + if (device_id == NULL || device_iccid == NULL) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ln_get_device_token_http: invalid parameters,device_id=%s,device_iccid=%s", device_id, device_iccid); + return ERRCODE_FAIL; + } + + token_header_ctx_t header_ctx = { + .device_id = device_id, + .device_iccid = device_iccid, + .device_model = device_model, + .device_version = device_version, + .sign_data = NULL + }; + + ln_http_request_t req = { + .url = LN_FULL_URL, + .method = LN_HTTP_METHOD_GET, + .is_https = true, + .header_size = 2048, + .response_size = 4096, + .build_header_cb = build_token_header, + .response_handler_cb = handle_token_response, + .user_data = &header_ctx, + .enable_cat1_keepalive = true + }; + + uint32_t result = ln_http_client_request(&req); + + // 清理sign_data + if (header_ctx.sign_data) + { + free(header_ctx.sign_data); + } + + return result; +} diff --git a/code/sdk/zhihui/leiniao/imsl_ln/ln_file_write_queue.c b/code/sdk/zhihui/leiniao/imsl_ln/ln_file_write_queue.c new file mode 100644 index 000000000..fd4a41c94 --- /dev/null +++ b/code/sdk/zhihui/leiniao/imsl_ln/ln_file_write_queue.c @@ -0,0 +1,544 @@ +#include "ln_file_write_queue.h" +#include "wearable_log.h" +#include +#include +#include +#include +#include +#include +#include +#include "watchdog.h" /* 用于看门狗喂狗 */ + +#define LN_FILE_WRITE_QUEUE_SIZE 64 +#define LN_FILE_WRITE_QUEUE_NAME "ln_file_write_queue" +#define LN_FILE_WRITE_THREAD_STACK_SIZE 0x2000 +#define LN_FILE_WRITE_THREAD_NAME "ln_file_write_thread" + +/* 全局变量 */ +static unsigned long g_file_write_queue = 0xFFFFFFFF; +static osThreadId_t g_file_write_thread = NULL; +static volatile bool g_file_write_thread_running = false; +static app_task_definition_t g_file_write_task_cfg = {0}; + +/* 文件写入线程函数 */ +static void ln_file_write_thread(void *arg) +{ + (void)arg; + ln_file_write_task_t task; + uint32_t msg_size = sizeof(ln_file_write_task_t); /* 必须初始化为期望读取的大小 */ + + WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[FILE_WRITE_QUEUE] Thread started"); + + while (g_file_write_thread_running) { + /* 从队列读取任务 */ + msg_size = sizeof(ln_file_write_task_t); /* 每次读取前重置为期望大小 */ + int ret = osal_msg_queue_read_copy(g_file_write_queue, (void *)&task, &msg_size, OSAL_MSGQ_WAIT_FOREVER); + + if (ret == OSAL_SUCCESS && msg_size == sizeof(ln_file_write_task_t)) { + /* 更新状态为正在写入 */ + if (task.ctx) { + task.ctx->status = LN_FILE_WRITE_STATUS_WRITING; + } + + /* 第一包:创建文件 */ + if (task.is_first_packet && task.file_handle && task.file_path && task.mode) { + if (*task.file_handle == NULL) { + *task.file_handle = fopen(task.file_path, task.mode); + if (*task.file_handle == NULL) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "[FILE_WRITE_QUEUE] Failed to open file: %s, mode: %s", + task.file_path, task.mode); + if (task.ctx) { + task.ctx->status = LN_FILE_WRITE_STATUS_ERROR; + task.ctx->error_code = ERRCODE_FAIL; + /* 减少引用计数(任务处理完成,虽然失败) */ + if (task.ctx->ref_count > 0) { + task.ctx->ref_count--; + } + } + /* 释放数据内存 */ + if (task.data) { + free((void *)task.data); + } + /* 释放文件路径和模式内存 */ + if (task.file_path) { + free((void *)task.file_path); + } + if (task.mode) { + free((void *)task.mode); + } + continue; /* 继续处理下一个任务,不阻塞 */ + } + + /* 设置文件缓冲区(64KB) */ + if (setvbuf(*task.file_handle, NULL, _IOFBF, 64 * 1024) != 0) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "[FILE_WRITE_QUEUE] setvbuf failed for: %s", + task.file_path); + } + + WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, + "[FILE_WRITE_QUEUE] File opened: %s", + task.file_path); + } + } + + /* 写入数据(关闭任务可能 data_len=0,跳过写入) */ + if (task.file_handle && *task.file_handle && task.data && task.data_len > 0) { + size_t written = fwrite(task.data, 1, task.data_len, *task.file_handle); + + if (written != task.data_len) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "[FILE_WRITE_QUEUE] Write failed: written=%zu, expected=%zu", + written, task.data_len); + if (task.ctx) { + task.ctx->status = LN_FILE_WRITE_STATUS_ERROR; + task.ctx->error_code = ERRCODE_FAIL; + /* 减少引用计数(任务处理完成,虽然失败) */ + if (task.ctx->ref_count > 0) { + task.ctx->ref_count--; + } + } + } else { + /* 更新已写入字节数 */ + if (task.ctx) { + task.ctx->total_written += written; + } + + /* 如果是最后一包,刷新缓冲区 */ + if (task.is_last_packet) { + fflush(*task.file_handle); + } + + /* 更新状态为完成(如果不是关闭任务) */ + if (task.ctx && !(task.is_last_packet && task.data_len == 0)) { + task.ctx->status = LN_FILE_WRITE_STATUS_DONE; + task.ctx->error_code = ERRCODE_SUCC; + } + } + } else if (task.is_last_packet && task.data_len == 0) { + /* 关闭任务(data_len=0),不需要写入数据,直接处理关闭 */ + WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, + "[FILE_WRITE_QUEUE] Close task received (data_len=0)"); + /* 状态将在关闭文件时更新 */ + } else { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "[FILE_WRITE_QUEUE] Invalid task: file_handle=%p, data=%p, len=%zu, is_last=%d", + task.file_handle ? *task.file_handle : NULL, + task.data, task.data_len, task.is_last_packet); + if (task.ctx) { + task.ctx->status = LN_FILE_WRITE_STATUS_ERROR; + task.ctx->error_code = ERRCODE_FAIL; + /* 减少引用计数(任务处理完成,虽然失败) */ + if (task.ctx->ref_count > 0) { + task.ctx->ref_count--; + } + } + } + + /* 最后一包:关闭文件 */ + if (task.is_last_packet && task.file_handle && *task.file_handle) { + /* 处理文件关闭 */ + if (task.ctx) { + /* 设置关闭状态 */ + task.ctx->status = LN_FILE_WRITE_STATUS_CLOSING; + + /* 减少当前任务的引用计数(任务处理完成) */ + if (task.ctx->ref_count > 0) { + task.ctx->ref_count--; + } + + /* 等待其他任务的引用计数归零(最多等待1秒,避免阻塞其他文件) */ + uint32_t wait_count = 0; + while (task.ctx->ref_count > 0 && wait_count < 100) { + osDelay(10); /* 延迟10ms */ + wait_count++; + } + + if (task.ctx->ref_count > 0) { + WEARABLE_LOGW(WEARABLE_LOG_MODULE_APP, + "[FILE_WRITE_QUEUE] Warning: ref_count=%u when closing file, forcing close", + task.ctx->ref_count); + /* 强制关闭,不阻塞其他文件处理 */ + task.ctx->ref_count = 0; + } + } + + fclose(*task.file_handle); + *task.file_handle = NULL; + + if (task.ctx) { + task.ctx->status = LN_FILE_WRITE_STATUS_CLOSED; + } + + WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, + "[FILE_WRITE_QUEUE] File closed"); + } else if (task.ctx) { + /* 非最后一包:任务处理完成,减少引用计数 */ + if (task.ctx->ref_count > 0) { + task.ctx->ref_count--; + } + } + + /* 释放数据内存 */ + if (task.data) { + free((void *)task.data); + } + + /* 释放文件路径和模式内存(如果是第一包) */ + if (task.file_path) { + free((void *)task.file_path); + } + if (task.mode) { + free((void *)task.mode); + } + } else if (ret != OSAL_SUCCESS) { + /* 队列读取错误 */ + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "[FILE_WRITE_QUEUE] Queue read error: %d", ret); + osDelay(100); + } + } + + WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[FILE_WRITE_QUEUE] Thread stopped"); +} + +/* 创建文件写入队列 */ +static void create_file_write_queue(void) +{ + if (osal_msg_queue_create(LN_FILE_WRITE_QUEUE_NAME, + LN_FILE_WRITE_QUEUE_SIZE, + &g_file_write_queue, + 0, + sizeof(ln_file_write_task_t)) != OSAL_SUCCESS) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "[FILE_WRITE_QUEUE] Failed to create queue"); + g_file_write_queue = 0xFFFFFFFF; + } else { + WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, + "[FILE_WRITE_QUEUE] Queue created (size=%d)", + LN_FILE_WRITE_QUEUE_SIZE); + } +} + +errcode_t ln_file_write_queue_init(void) +{ + if (g_file_write_thread_running) { + WEARABLE_LOGW(WEARABLE_LOG_MODULE_APP, + "[FILE_WRITE_QUEUE] Already initialized"); + return ERRCODE_SUCC; + } + + /* 创建队列 */ + create_file_write_queue(); + if (g_file_write_queue == 0xFFFFFFFF) { + return ERRCODE_FAIL; + } + + /* 创建写入线程 */ + g_file_write_thread_running = true; + g_file_write_task_cfg.create_queue_handle = create_file_write_queue; + g_file_write_task_cfg.attr.name = LN_FILE_WRITE_THREAD_NAME; + g_file_write_task_cfg.attr.priority = osPriorityNormal; + g_file_write_task_cfg.attr.stack_size = LN_FILE_WRITE_THREAD_STACK_SIZE; + g_file_write_task_cfg.func = (osThreadFunc_t)ln_file_write_thread; + g_file_write_task_cfg.use_mem = USE_EXTEND_MEM; + + errcode_t ret = uapi_create_osThread_custom(&g_file_write_task_cfg); + if (ret != ERRCODE_SUCC) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "[FILE_WRITE_QUEUE] Failed to create thread: %d", ret); + g_file_write_thread_running = false; + osal_msg_queue_delete(g_file_write_queue); + g_file_write_queue = 0xFFFFFFFF; + return ERRCODE_FAIL; + } + + g_file_write_thread = g_file_write_task_cfg.task_handle; + WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, + "[FILE_WRITE_QUEUE] Initialized (thread=%p)", + g_file_write_thread); + + return ERRCODE_SUCC; +} + +void ln_file_write_queue_deinit(void) +{ + if (!g_file_write_thread_running) { + return; + } + + /* 停止线程 */ + g_file_write_thread_running = false; + + /* 等待线程退出 */ + if (g_file_write_thread) { + osDelay(100); /* 给线程时间处理剩余任务 */ + osThreadTerminate(g_file_write_thread); + g_file_write_thread = NULL; + } + + /* 删除队列 */ + if (g_file_write_queue != 0xFFFFFFFF) { + osal_msg_queue_delete(g_file_write_queue); + g_file_write_queue = 0xFFFFFFFF; + } + + WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "[FILE_WRITE_QUEUE] Deinitialized"); +} + +errcode_t ln_file_write_queue_add_task( + FILE **file_handle, + ln_file_write_ctx_t *ctx, + const char *file_path, + const char *mode, + const uint8_t *data, + size_t data_len, + int is_first_packet, + int is_last_packet) +{ + if (!g_file_write_thread_running || g_file_write_queue == 0xFFFFFFFF) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "[FILE_WRITE_QUEUE] Not initialized"); + return ERRCODE_FAIL; + } + + if (!file_handle || !ctx) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "[FILE_WRITE_QUEUE] Invalid parameters: file_handle or ctx is NULL"); + return ERRCODE_FAIL; + } + + /* 对于关闭任务(is_last_packet=1 且 data_len=0),允许 data 为 NULL */ + if (!is_last_packet && (!data || data_len == 0)) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "[FILE_WRITE_QUEUE] Invalid parameters: data is NULL or data_len is 0 for non-last packet"); + return ERRCODE_FAIL; + } + + if (is_first_packet && (!file_path || !mode)) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "[FILE_WRITE_QUEUE] First packet requires file_path and mode"); + return ERRCODE_FAIL; + } + + /* 分配数据内存并复制(如果是关闭任务且 data_len=0,则不需要分配) */ + uint8_t *data_copy = NULL; + if (data_len > 0 && data) { + data_copy = (uint8_t *)malloc(data_len); + if (!data_copy) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "[FILE_WRITE_QUEUE] Failed to allocate memory for data"); + return ERRCODE_FAIL; + } + memcpy(data_copy, data, data_len); + } + + /* 复制文件路径(如果是第一包) */ + char *file_path_copy = NULL; + if (is_first_packet && file_path) { + file_path_copy = (char *)malloc(strlen(file_path) + 1); + if (!file_path_copy) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "[FILE_WRITE_QUEUE] Failed to allocate memory for file_path"); + free(data_copy); /* 释放已分配的数据内存 */ + return ERRCODE_FAIL; + } + strcpy(file_path_copy, file_path); + } + + /* 复制打开模式(如果是第一包) */ + char *mode_copy = NULL; + if (is_first_packet && mode) { + mode_copy = (char *)malloc(strlen(mode) + 1); + if (!mode_copy) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "[FILE_WRITE_QUEUE] Failed to allocate memory for mode"); + free(data_copy); /* 释放已分配的数据内存 */ + if (file_path_copy) free(file_path_copy); /* 释放已分配的文件路径内存 */ + return ERRCODE_FAIL; + } + strcpy(mode_copy, mode); + } + + /* 构建任务消息 */ + ln_file_write_task_t task = {0}; + task.file_handle = file_handle; + task.ctx = ctx; + task.file_path = file_path_copy; + task.mode = mode_copy; + task.data = data_copy; + task.data_len = data_len; + task.is_first_packet = is_first_packet; + task.is_last_packet = is_last_packet; + + /* 更新状态为等待写入 */ + ctx->status = LN_FILE_WRITE_STATUS_PENDING; + ctx->ref_count++; /* 增加引用计数 */ + + /* 发送到队列 */ + int ret = osal_msg_queue_write_copy(g_file_write_queue, (void *)&task, sizeof(task), 0); + if (ret != OSAL_SUCCESS) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "[FILE_WRITE_QUEUE] Failed to add task to queue: %d", ret); + /* 清理资源 */ + free(data_copy); + if (file_path_copy) free(file_path_copy); + if (mode_copy) free(mode_copy); + ctx->ref_count--; /* 减少引用计数 */ + ctx->status = LN_FILE_WRITE_STATUS_ERROR; + ctx->error_code = ERRCODE_FAIL; + return ERRCODE_FAIL; + } + + return ERRCODE_SUCC; +} + +ln_file_write_status_t ln_file_write_queue_get_status(ln_file_write_ctx_t *ctx) +{ + if (!ctx) { + return LN_FILE_WRITE_STATUS_ERROR; + } + return ctx->status; +} + +int ln_file_write_queue_get_error(ln_file_write_ctx_t *ctx) +{ + if (!ctx) { + return ERRCODE_FAIL; + } + return ctx->error_code; +} + +size_t ln_file_write_queue_get_written(ln_file_write_ctx_t *ctx) +{ + if (!ctx) { + return 0; + } + return ctx->total_written; +} + +errcode_t ln_file_write_queue_wait_done(ln_file_write_ctx_t *ctx, uint32_t timeout_ms) +{ + if (!ctx) { + return ERRCODE_FAIL; + } + + uint32_t elapsed = 0; + uint32_t check_interval = 10; /* 每10ms检查一次 */ + uint32_t last_watchdog_kick_time = 0; + const uint32_t WATCHDOG_KICK_INTERVAL_MS = 2000; /* 每2秒喂一次狗(看门狗超时8秒) */ + + /* 获取初始时间用于看门狗喂狗 */ + extern uint32_t uapi_tcxo_get_ms(void); + last_watchdog_kick_time = uapi_tcxo_get_ms(); + + while (elapsed < timeout_ms || timeout_ms == 0) { + if (ctx->status == LN_FILE_WRITE_STATUS_DONE) { + return ERRCODE_SUCC; + } + if (ctx->status == LN_FILE_WRITE_STATUS_ERROR) { + return ERRCODE_FAIL; + } + if (ctx->status == LN_FILE_WRITE_STATUS_CLOSED) { + return ERRCODE_SUCC; + } + + /* 定期喂狗,防止长时间等待导致看门狗超时触发 NMI */ + uint32_t current_time = uapi_tcxo_get_ms(); + uint32_t time_since_last_kick = (current_time >= last_watchdog_kick_time) ? + (current_time - last_watchdog_kick_time) : + (0xFFFFFFFF - last_watchdog_kick_time + current_time + 1); + if (time_since_last_kick >= WATCHDOG_KICK_INTERVAL_MS) { + extern errcode_t uapi_watchdog_kick(void); + uapi_watchdog_kick(); + last_watchdog_kick_time = current_time; + } + + osDelay(check_interval); + if (timeout_ms > 0) { + elapsed += check_interval; + } + } + + return ERRCODE_FAIL; /* 超时 */ +} + +errcode_t ln_file_write_queue_close_file(FILE **file_handle, ln_file_write_ctx_t *ctx) +{ + if (!file_handle || !ctx) { + return ERRCODE_FAIL; + } + + /* 等待所有写入任务完成 */ + if (ctx->status != LN_FILE_WRITE_STATUS_CLOSED) { + /* 等待状态变为DONE或ERROR */ + uint32_t wait_count = 0; + extern uint32_t uapi_tcxo_get_ms(void); + uint32_t last_watchdog_kick_time = uapi_tcxo_get_ms(); + const uint32_t WATCHDOG_KICK_INTERVAL_MS = 2000; /* 每2秒喂一次狗(看门狗超时8秒) */ + + while ((ctx->status == LN_FILE_WRITE_STATUS_PENDING || + ctx->status == LN_FILE_WRITE_STATUS_WRITING) && + wait_count < 100) { + /* 定期喂狗,防止长时间等待导致看门狗超时触发 NMI */ + uint32_t current_time = uapi_tcxo_get_ms(); + uint32_t time_since_last_kick = (current_time >= last_watchdog_kick_time) ? + (current_time - last_watchdog_kick_time) : + (0xFFFFFFFF - last_watchdog_kick_time + current_time + 1); + if (time_since_last_kick >= WATCHDOG_KICK_INTERVAL_MS) { + extern errcode_t uapi_watchdog_kick(void); + uapi_watchdog_kick(); + last_watchdog_kick_time = current_time; + } + + osDelay(10); + wait_count++; + } + + /* 如果还有未完成的任务,减少引用计数 */ + if (ctx->ref_count > 0) { + ctx->ref_count--; + } + + /* 如果文件还未关闭,且不是最后一包,需要发送关闭任务 */ + if (*file_handle != NULL && ctx->status != LN_FILE_WRITE_STATUS_CLOSING && + ctx->status != LN_FILE_WRITE_STATUS_CLOSED) { + /* 发送一个空的关闭任务(data_len=0 用于关闭文件) */ + errcode_t close_ret = ln_file_write_queue_add_task(file_handle, ctx, NULL, NULL, + NULL, 0, 0, 1); /* is_last_packet=1, data_len=0 */ + if (close_ret != ERRCODE_SUCC) { + WEARABLE_LOGW(WEARABLE_LOG_MODULE_APP, + "[FILE_WRITE_QUEUE] Failed to add close task, closing file directly"); + /* 如果无法添加关闭任务,直接关闭文件 */ + if (*file_handle) { + fclose(*file_handle); + *file_handle = NULL; + ctx->status = LN_FILE_WRITE_STATUS_CLOSED; + } + } + } + + /* 等待文件关闭完成 */ + wait_count = 0; + last_watchdog_kick_time = uapi_tcxo_get_ms(); /* 重置看门狗喂狗时间 */ + while (ctx->status != LN_FILE_WRITE_STATUS_CLOSED && wait_count < 100) { + /* 定期喂狗,防止长时间等待导致看门狗超时触发 NMI */ + uint32_t current_time = uapi_tcxo_get_ms(); + uint32_t time_since_last_kick = (current_time >= last_watchdog_kick_time) ? + (current_time - last_watchdog_kick_time) : + (0xFFFFFFFF - last_watchdog_kick_time + current_time + 1); + if (time_since_last_kick >= WATCHDOG_KICK_INTERVAL_MS) { + extern errcode_t uapi_watchdog_kick(void); + uapi_watchdog_kick(); + last_watchdog_kick_time = current_time; + } + + osDelay(10); + wait_count++; + } + } + + return ERRCODE_SUCC; +} + diff --git a/code/sdk/zhihui/leiniao/imsl_ln/ln_file_write_queue.h b/code/sdk/zhihui/leiniao/imsl_ln/ln_file_write_queue.h new file mode 100644 index 000000000..9907eaed8 --- /dev/null +++ b/code/sdk/zhihui/leiniao/imsl_ln/ln_file_write_queue.h @@ -0,0 +1,119 @@ +#ifndef LN_FILE_WRITE_QUEUE_H +#define LN_FILE_WRITE_QUEUE_H + +#ifdef __cplusplus +extern "C" +{ +#endif + +#include "stdint.h" +#include "errcode.h" +#include + +/* 文件写入状态 */ +typedef enum { + LN_FILE_WRITE_STATUS_PENDING = 0, /* 等待写入 */ + LN_FILE_WRITE_STATUS_WRITING, /* 正在写入 */ + LN_FILE_WRITE_STATUS_DONE, /* 写入完成 */ + LN_FILE_WRITE_STATUS_ERROR, /* 写入错误 */ + LN_FILE_WRITE_STATUS_CLOSING, /* 正在关闭 */ + LN_FILE_WRITE_STATUS_CLOSED /* 已关闭 */ +} ln_file_write_status_t; + +/* 文件写入状态控制结构(通过句柄指针访问) */ +typedef struct { + ln_file_write_status_t status; /* 写入状态 */ + int error_code; /* 错误码(ERRCODE_SUCC表示成功) */ + size_t total_written; /* 已写入总字节数 */ + volatile uint32_t ref_count; /* 引用计数(用于安全关闭) */ +} ln_file_write_ctx_t; + +/* 文件写入任务消息 */ +typedef struct { + FILE **file_handle; /* 文件句柄指针(双重指针,用于第一包创建) */ + ln_file_write_ctx_t *ctx; /* 状态控制结构指针 */ + const char *file_path; /* 文件路径(第一包时使用,可为NULL) */ + const char *mode; /* 文件打开模式(第一包时使用,如"wb+"或"ab+") */ + const uint8_t *data; /* 要写入的数据 */ + size_t data_len; /* 数据长度 */ + int is_first_packet; /* 是否为第一包(需要创建文件) */ + int is_last_packet; /* 是否为最后一包(写入后关闭文件) */ +} ln_file_write_task_t; + +/** + * @brief 初始化异步文件写入队列系统 + * @return ERRCODE_SUCC 成功,ERRCODE_FAIL 失败 + */ +errcode_t ln_file_write_queue_init(void); + +/** + * @brief 反初始化异步文件写入队列系统 + */ +void ln_file_write_queue_deinit(void); + +/** + * @brief 添加文件写入任务到队列 + * @param file_handle 文件句柄指针(双重指针,第一包时会被创建) + * @param ctx 状态控制结构指针(必须由调用者分配,用于状态同步) + * @param file_path 文件路径(仅第一包需要,后续可为NULL) + * @param mode 文件打开模式(仅第一包需要,如"wb+"或"ab+",后续可为NULL) + * @param data 要写入的数据(会被复制) + * @param data_len 数据长度 + * @param is_first_packet 是否为第一包 + * @param is_last_packet 是否为最后一包 + * @return ERRCODE_SUCC 成功,ERRCODE_FAIL 失败 + */ +errcode_t ln_file_write_queue_add_task( + FILE **file_handle, + ln_file_write_ctx_t *ctx, + const char *file_path, + const char *mode, + const uint8_t *data, + size_t data_len, + int is_first_packet, + int is_last_packet +); + +/** + * @brief 查询文件写入状态 + * @param ctx 状态控制结构指针 + * @return 当前状态 + */ +ln_file_write_status_t ln_file_write_queue_get_status(ln_file_write_ctx_t *ctx); + +/** + * @brief 获取写入错误码 + * @param ctx 状态控制结构指针 + * @return 错误码(ERRCODE_SUCC表示成功) + */ +int ln_file_write_queue_get_error(ln_file_write_ctx_t *ctx); + +/** + * @brief 获取已写入总字节数 + * @param ctx 状态控制结构指针 + * @return 已写入总字节数 + */ +size_t ln_file_write_queue_get_written(ln_file_write_ctx_t *ctx); + +/** + * @brief 等待文件写入完成(阻塞直到状态变为DONE或ERROR) + * @param ctx 状态控制结构指针 + * @param timeout_ms 超时时间(毫秒),0表示无限等待 + * @return ERRCODE_SUCC 成功,ERRCODE_FAIL 失败或超时 + */ +errcode_t ln_file_write_queue_wait_done(ln_file_write_ctx_t *ctx, uint32_t timeout_ms); + +/** + * @brief 安全关闭文件(等待所有写入任务完成后再关闭) + * @param file_handle 文件句柄指针 + * @param ctx 状态控制结构指针 + * @return ERRCODE_SUCC 成功,ERRCODE_FAIL 失败 + */ +errcode_t ln_file_write_queue_close_file(FILE **file_handle, ln_file_write_ctx_t *ctx); + +#ifdef __cplusplus +} +#endif + +#endif /* LN_FILE_WRITE_QUEUE_H */ + diff --git a/code/sdk/zhihui/leiniao/imsl_ln/ln_http_client.c b/code/sdk/zhihui/leiniao/imsl_ln/ln_http_client.c new file mode 100644 index 000000000..532c2bc1c --- /dev/null +++ b/code/sdk/zhihui/leiniao/imsl_ln/ln_http_client.c @@ -0,0 +1,247 @@ +/** + * @file ln_http_client.c + * @brief 统一的HTTP客户端实现 + */ + +#include "ln_http_client.h" +#include "ln_api.h" +#include "errcode.h" +#include +#include +#include +#include "los_task.h" + +// CAT1保活API声明 +#if defined(SUPPORT_CAT1_SERVICE) || defined(SUPPORT_PPP_SERVICE) +extern void cat1_api_add_cat1_app_vote(void); +extern void cat1_api_remove_cat1_app_vote(void); +extern void cat1_api_keep_wakeup(uint8_t keep_wakeup); +extern void cat1_api_disable_cat1_cmd(uint8_t disable); +#endif + +/* 默认Header构建函数 */ +char* ln_http_build_default_header(const char *device_id, const char *device_token, const char *extra_headers) +{ + if (!device_id || !device_token) { + return NULL; + } + + size_t header_size = 512; + if (extra_headers) { + header_size += strlen(extra_headers); + } + + char *header = (char*)malloc(header_size); + if (!header) { + return NULL; + } + + int len = snprintf(header, header_size, + "deviceId: %s\r\n" + "deviceToken: %s\r\n" + "Content-Type: application/json\r\n", + device_id, device_token); + + if (len > 0 && extra_headers && (size_t)len < header_size) { + len += snprintf(header + len, header_size - len, "%s", extra_headers); + } + + if (len <= 0 || (size_t)len >= header_size) { + free(header); + return NULL; + } + + return header; +} + +/* 带设备信息的Header构建函数 */ +char* ln_http_build_device_header(const char *device_id, const char *device_token, const char *extra_headers) +{ + if (!device_id || !device_token) { + return NULL; + } + + size_t header_size = 768; + if (extra_headers) { + header_size += strlen(extra_headers); + } + + const char *model = uapi_ln_get_device_model(); + if (!model) model = "AB101"; + const char *version = uapi_ln_get_device_version(); + if (!version) version = "1.0.0"; + + char *header = (char*)malloc(header_size); + if (!header) { + return NULL; + } + + int len = snprintf(header, header_size, + "deviceId: %s\r\n" + "deviceToken: %s\r\n" + "deviceModel: %s\r\n" + "deviceVersion: %s\r\n" + "Content-Type: application/json\r\n", + device_id, device_token, model, version); + + if (len > 0 && extra_headers && (size_t)len < header_size) { + len += snprintf(header + len, header_size - len, "%s", extra_headers); + } + + if (len <= 0 || (size_t)len >= header_size) { + free(header); + return NULL; + } + + return header; +} + +/* 统一的HTTP请求执行函数 */ +uint32_t ln_http_client_request(const ln_http_request_t *req) +{ + if (!req || !req->url || !req->response_handler_cb) { + return ERRCODE_FAIL; + } + + // 1. CAT1保活管理 + if (req->enable_cat1_keepalive) { + #if defined(SUPPORT_CAT1_SERVICE) || defined(SUPPORT_PPP_SERVICE) + cat1_api_add_cat1_app_vote(); + cat1_api_disable_cat1_cmd(1); + cat1_api_keep_wakeup(1); + LOS_Msleep(200); + #endif + } + + // 2. HTTP客户端初始化 + HttpClient client = {0}; + HttpClientData clientData = {0}; + client.isHttp = !req->is_https; + client.remotePort = req->port > 0 ? req->port : (req->is_https ? 443 : 80); + + // 3. 构建Header + char *header_buf = NULL; + if (req->build_header_cb) { + header_buf = req->build_header_cb(req->user_data); + } else { + // 使用默认header + const char *device_id = uapi_ln_get_device_id(); + const char *device_token = uapi_ln_get_device_token(); + if (device_id && device_token) { + header_buf = ln_http_build_default_header(device_id, device_token, NULL); + } + } + + if (!header_buf) { + // 如果有错误回调,调用它 + if (req->error_handler_cb) { + req->error_handler_cb(HTTP_EARG, "Header build failed", req->user_data); + } + goto cleanup_error; + } + HttpClientSetCustomHeader(&client, header_buf); + + // 4. 准备HTTP客户端 + int header_size = req->header_size > 0 ? req->header_size : 2048; + int resp_size = req->response_size > 0 ? req->response_size : 8192; + + HTTPC_RESULT prep = ln_http_prepare_auto(&clientData, header_size, resp_size); + if (prep != HTTP_SUCCESS) { + // 调用错误回调前,确保保护处理已做好 + if (req->error_handler_cb) { + req->error_handler_cb(prep, "HTTP prepare failed", req->user_data); + } + goto cleanup_error; + } + + // 5. 构建Body(POST/PUT需要) + char *body_buf = NULL; + char content_type[128] = "application/json"; + int body_len = 0; + + if ((req->method == LN_HTTP_METHOD_POST || req->method == LN_HTTP_METHOD_PUT) && req->build_body_cb) { + body_buf = req->build_body_cb(req->user_data, &body_len, content_type, sizeof(content_type)); + if (body_buf && body_len > 0) { + clientData.postBuf = body_buf; + clientData.postBufLen = body_len; + clientData.postContentType = content_type; + } + } + + // 6. 发送HTTP请求 + HTTPC_RESULT res; + switch (req->method) { + case LN_HTTP_METHOD_GET: + res = HttpClientGetRequest(&client, req->url, &clientData); + break; + case LN_HTTP_METHOD_POST: + res = HttpClientPostRequest(&client, req->url, &clientData); + break; + case LN_HTTP_METHOD_PUT: + res = HttpClientPutRequest(&client, req->url, &clientData); + break; + case LN_HTTP_METHOD_DELETE: + res = HttpClientDelete(&client, req->url, &clientData); + break; + case LN_HTTP_METHOD_HEAD: + res = HttpClientHeadRequest(&client, req->url, &clientData); + break; + default: + res = HTTP_EARG; + break; + } + + if (res != HTTP_SUCCESS) { + // 调用错误回调前,确保保护处理已做好 + if (req->error_handler_cb) { + req->error_handler_cb(res, "HTTP request failed", req->user_data); + } + goto cleanup_error; + } + + // 7. 检查HTTP状态码 + int status_code = HttpClientGetResponseCode(&client); + + // 8. 处理响应 + uint32_t result = ERRCODE_FAIL; + if (clientData.responseBuf && clientData.responseBufLen > 0) { + int real_len = clientData.responseContentLen > 0 ? + clientData.responseContentLen : clientData.responseBufLen; + result = req->response_handler_cb(clientData.responseBuf, real_len, status_code, req->user_data); + } else { + // 空响应也调用回调,让回调决定如何处理 + result = req->response_handler_cb(NULL, 0, status_code, req->user_data); + } + + // 清理资源 + HttpClientUnprepare(&clientData); + HttpClientClse(&client); + if (header_buf) free(header_buf); + if (body_buf) free(body_buf); + + if (req->enable_cat1_keepalive) { + #if defined(SUPPORT_CAT1_SERVICE) || defined(SUPPORT_PPP_SERVICE) + cat1_api_keep_wakeup(0); + cat1_api_disable_cat1_cmd(0); + cat1_api_remove_cat1_app_vote(); + #endif + } + + // 返回响应处理的结果 + return result; + +cleanup_error: + if (req->enable_cat1_keepalive) { + #if defined(SUPPORT_CAT1_SERVICE) || defined(SUPPORT_PPP_SERVICE) + cat1_api_keep_wakeup(0); + cat1_api_disable_cat1_cmd(0); + cat1_api_remove_cat1_app_vote(); + #endif + } + if (header_buf) free(header_buf); + if (body_buf) free(body_buf); + HttpClientUnprepare(&clientData); + HttpClientClse(&client); + return ERRCODE_FAIL; +} + diff --git a/code/sdk/zhihui/leiniao/imsl_ln/ln_http_client.h b/code/sdk/zhihui/leiniao/imsl_ln/ln_http_client.h new file mode 100644 index 000000000..903bbb393 --- /dev/null +++ b/code/sdk/zhihui/leiniao/imsl_ln/ln_http_client.h @@ -0,0 +1,128 @@ +/** + * @file ln_http_client.h + * @brief 统一的HTTP客户端接口 + * + * 该接口封装了所有HTTP请求的通用逻辑: + * - CAT1保活管理 + * - HTTP客户端初始化 + * - Header构建 + * - 请求发送 + * - 响应处理 + * - 资源清理 + * + * 通过回调函数实现不同业务逻辑的定制化。 + */ + +#ifndef LN_HTTP_CLIENT_H +#define LN_HTTP_CLIENT_H + +#include +#include + +/* 错误码定义 */ +#define LN_HTTP_ERR_OK 0 +#define LN_HTTP_ERR_INVALID_PARAM -1 +#define LN_HTTP_ERR_MEMORY -2 +#define LN_HTTP_ERR_NETWORK -3 +#define LN_HTTP_ERR_RESPONSE -4 + +/* HTTP方法枚举 */ +typedef enum { + LN_HTTP_METHOD_GET = 0, + LN_HTTP_METHOD_POST, + LN_HTTP_METHOD_PUT, + LN_HTTP_METHOD_DELETE, + LN_HTTP_METHOD_HEAD +} ln_http_method_t; + +/* Header构建回调函数类型 + * @param user_data 用户数据 + * @return 成功返回分配的header字符串指针(需要调用者释放),失败返回NULL + */ +typedef char* (*ln_http_build_header_cb_t)(void *user_data); + +/* Body构建回调函数类型 + * @param user_data 用户数据 + * @param body_len_out 输出:body长度 + * @param content_type_out 输出:Content-Type字符串 + * @param content_type_size Content-Type缓冲区大小 + * @return 成功返回分配的body字符串指针(需要调用者释放),失败返回NULL + */ +typedef char* (*ln_http_build_body_cb_t)(void *user_data, int *body_len_out, + char *content_type_out, int content_type_size); + +/* 响应处理回调函数类型 + * @param response_data 响应数据(可能为NULL) + * @param response_len 响应数据长度 + * @param status_code HTTP状态码 + * @param user_data 用户数据 + * @return ERRCODE_SUCC(0)表示处理成功,ERRCODE_FAIL(非0)表示处理失败 + */ +typedef uint32_t (*ln_http_response_handler_cb_t)(const char *response_data, int response_len, + int status_code, void *user_data); + +/* 错误处理回调函数类型(可选) + * @param error_code 错误码 + * @param error_msg 错误消息 + * @param user_data 用户数据 + */ +typedef void (*ln_http_error_handler_cb_t)(int error_code, const char *error_msg, void *user_data); + +/* HTTP客户端配置 */ +typedef struct { + const char *url; // 请求URL(必需) + ln_http_method_t method; // HTTP方法(必需) + bool is_https; // 是否HTTPS(true=443, false=80) + uint16_t port; // 端口号(如果is_https=false但port!=80时使用) + uint32_t timeout_ms; // 超时时间(毫秒,0表示使用默认值) + int header_size; // Header缓冲区大小(0表示使用默认值2048) + int response_size; // 响应缓冲区大小(0表示使用默认值8192) + + // Header构建回调(如果为NULL,则使用默认header:deviceId + deviceToken) + ln_http_build_header_cb_t build_header_cb; + + // Body构建回调(POST/PUT需要,GET/DELETE/HEAD可设为NULL) + ln_http_build_body_cb_t build_body_cb; + + // 响应处理回调(必需) + ln_http_response_handler_cb_t response_handler_cb; + + // 错误处理回调(可选) + ln_http_error_handler_cb_t error_handler_cb; + + // 用户数据,传递给所有回调 + void *user_data; + + // 是否启用CAT1保活(默认true) + bool enable_cat1_keepalive; +} ln_http_request_t; + +/** + * @brief 执行HTTP请求(统一接口) + * @param req HTTP请求配置 + * @return ERRCODE_SUCC 成功,ERRCODE_FAIL 失败 + */ +uint32_t ln_http_client_request(const ln_http_request_t *req); + +/** + * @brief 构建默认Header(deviceId + deviceToken) + * @param device_id 设备ID + * @param device_token 设备Token + * @param extra_headers 额外的header字段(可选,格式: "key: value\r\n...") + * @return 分配的header字符串,需要调用者释放(使用free) + */ +char* ln_http_build_default_header(const char *device_id, const char *device_token, + const char *extra_headers); + +/** + * @brief 构建带设备信息的Header(deviceId + deviceToken + deviceModel + deviceVersion) + * @param device_id 设备ID + * @param device_token 设备Token + * @param extra_headers 额外的header字段(可选) + * @return 分配的header字符串,需要调用者释放(使用free) + */ +char* ln_http_build_device_header(const char *device_id, const char *device_token, + const char *extra_headers); + +#endif /* LN_HTTP_CLIENT_H */ + diff --git a/code/sdk/zhihui/leiniao/imsl_ln/ln_http_download_client.c b/code/sdk/zhihui/leiniao/imsl_ln/ln_http_download_client.c new file mode 100644 index 000000000..1b2d3086d --- /dev/null +++ b/code/sdk/zhihui/leiniao/imsl_ln/ln_http_download_client.c @@ -0,0 +1,278 @@ +/** + * @file ln_http_download_client.c + * @brief 流式HTTP下载客户端实现 + */ + +#include "ln_http_download_client.h" +#include "ln_api.h" +#include "errcode.h" +#include +#include +#include +#include "los_task.h" +#include "watchdog.h" /* 用于看门狗喂狗 */ + +// CAT1保活API声明 +#if defined(SUPPORT_CAT1_SERVICE) || defined(SUPPORT_PPP_SERVICE) +extern void cat1_api_add_cat1_app_vote(void); +extern void cat1_api_remove_cat1_app_vote(void); +extern void cat1_api_keep_wakeup(uint8_t keep_wakeup); +extern void cat1_api_disable_cat1_cmd(uint8_t disable); +#endif + +/* 流式HTTP下载执行函数 */ +uint32_t ln_http_download_stream(const ln_http_download_request_t *req) +{ + if (!req || !req->url || !req->chunk_handler_cb) { + return ERRCODE_FAIL; + } + + // 1. CAT1保活管理 + if (req->enable_cat1_keepalive) { + #if defined(SUPPORT_CAT1_SERVICE) || defined(SUPPORT_PPP_SERVICE) + cat1_api_add_cat1_app_vote(); + cat1_api_disable_cat1_cmd(1); + cat1_api_keep_wakeup(1); + LOS_Msleep(200); + #endif + } + + // 2. HTTP客户端初始化 + HttpClient client = {0}; + HttpClientData clientData = {0}; + client.isHttp = !req->is_https; + client.remotePort = req->port > 0 ? req->port : (req->is_https ? 443 : 80); + + // 3. 构建Header + char *header_buf = NULL; + if (req->build_header_cb) { + header_buf = req->build_header_cb(req->header_user_data); + } else { + // 使用默认header + const char *device_id = uapi_ln_get_device_id(); + const char *device_token = uapi_ln_get_device_token(); + if (device_id && device_token) { + header_buf = ln_http_build_default_header(device_id, device_token, NULL); + } + } + + if (!header_buf) { + if (req->error_handler_cb) { + req->error_handler_cb(-1, "Header build failed", req->user_data); + } + goto cleanup_error; + } + + // 追加Range头(如果指定) + if (req->range_header) { + size_t header_len = strlen(header_buf); + size_t range_len = strlen(req->range_header); + char *new_header = (char *)realloc(header_buf, header_len + range_len + 3); + if (new_header) { + header_buf = new_header; + strcat(header_buf, req->range_header); + strcat(header_buf, "\r\n"); + } else { + // realloc 失败,释放原来的 header_buf 并返回错误 + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "[HTTP_DOWNLOAD] Failed to realloc header for range header"); + if (req->error_handler_cb) { + req->error_handler_cb(-1, "Failed to allocate memory for range header", req->user_data); + } + free(header_buf); + goto cleanup_error; + } + } + + HttpClientSetCustomHeader(&client, header_buf); + + // 4. 准备HTTP客户端 + int header_size = req->header_size > 0 ? req->header_size : 2048; + int resp_size = req->response_size > 0 ? req->response_size : 8192; + + HTTPC_RESULT prep = ln_http_prepare_auto(&clientData, header_size, resp_size); + if (prep != HTTP_SUCCESS) { + if (req->error_handler_cb) { + req->error_handler_cb(prep, "HTTP prepare failed", req->user_data); + } + goto cleanup_error; + } + + // 5. 构建Body(POST需要) + char *body_buf = NULL; + char content_type[128] = "application/json"; + int body_len = 0; + + if (req->method == LN_DOWNLOAD_METHOD_POST && req->build_body_cb) { + body_buf = req->build_body_cb(req->body_user_data, &body_len, content_type, sizeof(content_type)); + if (body_buf && body_len > 0) { + clientData.postBuf = body_buf; + clientData.postBufLen = body_len; + clientData.postContentType = content_type; + } + } + + // 6. 设置分块传输标志 + if (req->enable_chunked) { + clientData.isChunked = true; + } + + // 7. 建立连接 + int ret = HttpClientConn(&client, req->url); + if (ret != 0) { + if (req->error_handler_cb) { + req->error_handler_cb(ret, "Connection failed", req->user_data); + } + goto cleanup_error; + } + + // 8. 发送HTTP请求 + HTTP_REQUEST_TYPE http_method = (req->method == LN_DOWNLOAD_METHOD_POST) ? HTTP_POST : HTTP_GET; + ret = HttpClientSend(&client, req->url, http_method, &clientData); + if (ret != 0) { + if (req->error_handler_cb) { + req->error_handler_cb(ret, "Send request failed", req->user_data); + } + goto cleanup_error; + } + + // 9. 接收首包并检查状态码 + HTTPC_RESULT first_recv = HttpClientRecvResponse(&client, &clientData); + if (!(first_recv == HTTP_SUCCESS || first_recv == HTTP_EAGAIN)) { + if (req->error_handler_cb) { + req->error_handler_cb(first_recv, "First receive failed", req->user_data); + } + goto cleanup_error; + } + + int status_code = HttpClientGetResponseCode(&client); + if (status_code < 200 || status_code >= 300) { + if (req->error_handler_cb) { + char error_msg[128]; + snprintf(error_msg, sizeof(error_msg), "HTTP status code %d", status_code); + req->error_handler_cb(status_code, error_msg, req->user_data); + } + goto cleanup_error; + } + + // 10. 处理首包数据 + size_t total_downloaded = 0; + + if (clientData.contentBlockLen > 0) { + uint32_t chunk_result = req->chunk_handler_cb(clientData.responseBuf, clientData.contentBlockLen, req->user_data); + if (chunk_result != ERRCODE_SUCC) { + goto cleanup_error; + } + total_downloaded += clientData.contentBlockLen; + + // 进度回调(首包总是调用,确保UI有初始进度) + if (req->progress_cb) { + size_t total = clientData.responseContentLen > 0 ? (size_t)clientData.responseContentLen : 0; + req->progress_cb(total_downloaded, total, req->user_data); + // 初始化静态变量(用于后续频率限制) + static uint32_t last_progress_cb_time = 0; + static size_t last_progress_cb_bytes = 0; + extern uint32_t uapi_tcxo_get_ms(void); + last_progress_cb_time = uapi_tcxo_get_ms(); + last_progress_cb_bytes = total_downloaded; + } + } + + // 11. 循环接收后续数据块 + // 用于定期喂狗,防止长时间下载导致看门狗超时 + extern uint32_t uapi_tcxo_get_ms(void); + uint32_t last_watchdog_kick_time = uapi_tcxo_get_ms(); + const uint32_t WATCHDOG_KICK_INTERVAL_MS = 2000; // 每2秒喂一次狗(看门狗超时8秒) + + while (clientData.isMore) { + // 定期喂狗,防止长时间下载导致看门狗超时触发 NMI + uint32_t current_time = uapi_tcxo_get_ms(); + uint32_t time_since_last_kick = (current_time >= last_watchdog_kick_time) ? + (current_time - last_watchdog_kick_time) : + (0xFFFFFFFF - last_watchdog_kick_time + current_time + 1); + if (time_since_last_kick >= WATCHDOG_KICK_INTERVAL_MS) { + extern errcode_t uapi_watchdog_kick(void); + uapi_watchdog_kick(); + last_watchdog_kick_time = current_time; + } + + HTTPC_RESULT recv_res = HttpClientRecvResponse(&client, &clientData); + + if (recv_res == HTTP_SUCCESS || recv_res == HTTP_EAGAIN) { + if (clientData.contentBlockLen > 0) { + // 处理数据块 + uint32_t chunk_result = req->chunk_handler_cb(clientData.responseBuf, clientData.contentBlockLen, req->user_data); + if (chunk_result != ERRCODE_SUCC) { + // 用户回调要求中止下载 + goto cleanup_error; + } + total_downloaded += clientData.contentBlockLen; + + // 进度回调(优化:限制更新频率,避免频繁UI刷新影响下载性能) + if (req->progress_cb) { + static uint32_t last_progress_cb_time = 0; + static size_t last_progress_cb_bytes = 0; + #define PROGRESS_CB_UPDATE_INTERVAL_MS 1000 // 每1秒更新一次 + #define PROGRESS_CB_UPDATE_THRESHOLD_BYTES (64 * 1024) // 或每64KB更新一次 + + // 获取当前时间(毫秒) + extern uint32_t uapi_tcxo_get_ms(void); + uint32_t current_time = uapi_tcxo_get_ms(); + + // 限制更新频率:每1秒或每64KB更新一次 + // 处理时间溢出:如果 current_time < last_progress_cb_time,说明时间溢出,强制更新 + uint32_t time_delta = (current_time >= last_progress_cb_time) ? + (current_time - last_progress_cb_time) : + (0xFFFFFFFF - last_progress_cb_time + current_time + 1); + size_t bytes_delta = total_downloaded - last_progress_cb_bytes; + if (time_delta >= PROGRESS_CB_UPDATE_INTERVAL_MS || + bytes_delta >= PROGRESS_CB_UPDATE_THRESHOLD_BYTES) { + size_t total = clientData.responseContentLen > 0 ? (size_t)clientData.responseContentLen : 0; + req->progress_cb(total_downloaded, total, req->user_data); + last_progress_cb_time = current_time; + last_progress_cb_bytes = total_downloaded; + } + } + } + } else { + // 接收结束或出错 + if (recv_res != HTTP_SUCCESS && req->error_handler_cb) { + char error_msg[128]; + snprintf(error_msg, sizeof(error_msg), "Receive error: %d", recv_res); + req->error_handler_cb(recv_res, error_msg, req->user_data); + } + break; + } + } + + // 清理资源 + HttpClientUnprepare(&clientData); + HttpClientClse(&client); + if (header_buf) free(header_buf); + if (body_buf) free(body_buf); + + if (req->enable_cat1_keepalive) { + #if defined(SUPPORT_CAT1_SERVICE) || defined(SUPPORT_PPP_SERVICE) + cat1_api_keep_wakeup(0); + cat1_api_disable_cat1_cmd(0); + cat1_api_remove_cat1_app_vote(); + #endif + } + + return ERRCODE_SUCC; + +cleanup_error: + if (req->enable_cat1_keepalive) { + #if defined(SUPPORT_CAT1_SERVICE) || defined(SUPPORT_PPP_SERVICE) + cat1_api_keep_wakeup(0); + cat1_api_disable_cat1_cmd(0); + cat1_api_remove_cat1_app_vote(); + #endif + } + if (header_buf) free(header_buf); + if (body_buf) free(body_buf); + HttpClientUnprepare(&clientData); + HttpClientClse(&client); + return ERRCODE_FAIL; +} + diff --git a/code/sdk/zhihui/leiniao/imsl_ln/ln_http_download_client.h b/code/sdk/zhihui/leiniao/imsl_ln/ln_http_download_client.h new file mode 100644 index 000000000..05a039c72 --- /dev/null +++ b/code/sdk/zhihui/leiniao/imsl_ln/ln_http_download_client.h @@ -0,0 +1,99 @@ +/** + * @file ln_http_download_client.h + * @brief 流式HTTP下载客户端接口 + * + * 该接口专门用于流式下载场景(大文件下载、SSE流等): + * - CAT1保活管理 + * - HTTP客户端初始化 + * - Header构建 + * - 流式数据接收 + * - 数据块处理回调 + * - 进度上报 + * - 资源清理 + * + * 与 ln_http_client.h 的区别: + * - ln_http_client: 一次性接收完整响应(适合小文件、API响应) + * - ln_http_download_client: 流式分块接收(适合大文件、实时流) + */ + +#ifndef LN_HTTP_DOWNLOAD_CLIENT_H +#define LN_HTTP_DOWNLOAD_CLIENT_H + +#include +#include +#include + +// 复用统一接口的Header和Body构建回调类型 +#include "ln_http_client.h" + +/* HTTP方法枚举(流式下载主要支持GET和POST) */ +typedef enum { + LN_DOWNLOAD_METHOD_GET = 0, + LN_DOWNLOAD_METHOD_POST +} ln_download_method_t; + +/* 数据块处理回调函数类型 + * @param data 接收到的数据块 + * @param len 数据块长度 + * @param user_data 用户数据 + * @return ERRCODE_SUCC 继续下载,ERRCODE_FAIL 中止下载 + */ +typedef uint32_t (*ln_download_chunk_handler_cb_t)(const char *data, int len, void *user_data); + +/* 进度回调函数类型(可选) + * @param downloaded 已下载字节数 + * @param total 总字节数(如果未知则为0) + * @param user_data 用户数据 + */ +typedef void (*ln_download_progress_cb_t)(size_t downloaded, size_t total, void *user_data); + +/* 错误处理回调函数类型(可选) + * @param error_code 错误码 + * @param error_msg 错误消息 + * @param user_data 用户数据 + */ +typedef void (*ln_download_error_handler_cb_t)(int error_code, const char *error_msg, void *user_data); + +/* 流式下载请求配置 */ +typedef struct { + const char *url; // 请求URL(必需) + ln_download_method_t method; // HTTP方法(GET/POST) + bool is_https; // 是否HTTPS(true=443, false=80) + uint16_t port; // 端口号(如果is_https=false但port!=80时使用) + int header_size; // Header缓冲区大小(0表示使用默认值2048) + int response_size; // 响应缓冲区大小(0表示使用默认值8192) + + // Header构建回调(如果为NULL,则使用默认header:deviceId + deviceToken) + ln_http_build_header_cb_t build_header_cb; + void *header_user_data; // Header构建回调的用户数据 + + // Body构建回调(POST需要,GET可设为NULL) + ln_http_build_body_cb_t build_body_cb; + void *body_user_data; // Body构建回调的用户数据 + + // 流式处理回调 + ln_download_chunk_handler_cb_t chunk_handler_cb; // 数据块处理回调(必需) + ln_download_progress_cb_t progress_cb; // 进度回调(可选) + ln_download_error_handler_cb_t error_handler_cb; // 错误处理回调(可选) + void *user_data; // 所有回调的用户数据 + + // 是否启用CAT1保活(默认true) + bool enable_cat1_keepalive; + + // 是否启用分块传输(chunked transfer encoding) + bool enable_chunked; + + // 断点续传相关(可选) + const char *range_header; // Range头(如 "bytes=1024-"),如果为NULL则不使用Range +} ln_http_download_request_t; + +/** + * @brief 执行流式HTTP下载 + * @param req 流式下载请求配置 + * @return ERRCODE_SUCC 成功,ERRCODE_FAIL 失败 + */ +uint32_t ln_http_download_stream(const ln_http_download_request_t *req); + +#endif /* LN_HTTP_DOWNLOAD_CLIENT_H */ + + diff --git a/code/sdk/zhihui/ppp/src/ppp_cat1_api.c b/code/sdk/zhihui/ppp/src/ppp_cat1_api.c index 28b4d8fe1..6747d6cc3 100644 --- a/code/sdk/zhihui/ppp/src/ppp_cat1_api.c +++ b/code/sdk/zhihui/ppp/src/ppp_cat1_api.c @@ -191,7 +191,7 @@ bool cat1_api_custom_is_cmd_rx_enabled(void) void cat1_api_remove_cat1_vote(void) { uint8_t cnt = pm_veto_get_id_cnt(PM_ID_CAT1); - if (cnt == 1) { + if (cnt > 0) { uapi_pm_remove_sleep_veto(PM_ID_CAT1); } else { // PPP_DEBUG_PRINT("CAT1 SERVICE MCU has delete pm_id_cat1 vote\r\n"); @@ -210,6 +210,26 @@ void cat1_api_add_cat1_vote(void) PPP_DEBUG_PRINT("\r\nCAT1 SERVICE MCU WAKEUP SUCCESS\r\n"); } +void cat1_api_add_cat1_app_vote(void) +{ + uint8_t cnt = pm_veto_get_id_cnt(PM_ID_CAT1_APP); + if (cnt == 0) { + uapi_pm_add_sleep_veto(PM_ID_CAT1_APP); + } else { + // PPP_DEBUG_PRINT("CAT1 SERVICE MCU has got pm_id_cat1_app vote\r\n"); + } +} + +void cat1_api_remove_cat1_app_vote(void) +{ + uint8_t cnt = pm_veto_get_id_cnt(PM_ID_CAT1_APP); + if (cnt > 0) { + uapi_pm_remove_sleep_veto(PM_ID_CAT1_APP); + } else { + // PPP_DEBUG_PRINT("CAT1 SERVICE MCU has delete pm_id_cat1_app vote\r\n"); + } +} + errcode_t cat1_api_disable_cat1_cmd(uint8_t disable_cmd) { return ERRCODE_SUCC; diff --git a/code/sdk/zhihui/services/gnss/src/gnss_http_server.c b/code/sdk/zhihui/services/gnss/src/gnss_http_server.c index 29e06e057..46c7eea54 100644 --- a/code/sdk/zhihui/services/gnss/src/gnss_http_server.c +++ b/code/sdk/zhihui/services/gnss/src/gnss_http_server.c @@ -1548,6 +1548,7 @@ static void agnss_process_complete_response(void) #ifdef SUPPORT_CAT1_SERVICE cat1_api_keep_wakeup(0); cat1_api_wakeup_cat1(0); + cat1_api_remove_cat1_app_vote(); #endif // 验证下载的文件 @@ -1720,6 +1721,11 @@ int download_agnss_files(void) char *full_url = malloc(512); if (full_url == NULL) { printf("Error: Failed to allocate memory for full_url in download_agnss_files\n"); +#ifdef SUPPORT_CAT1_SERVICE + cat1_api_remove_cat1_app_vote(); + cat1_api_keep_wakeup(0); + cat1_api_wakeup_cat1(0); +#endif return -1; } snprintf(full_url, 512, diff --git a/code/sdk/zhihui/utils/custom_utils.c b/code/sdk/zhihui/utils/custom_utils.c index 18e15af03..5a91bd592 100644 --- a/code/sdk/zhihui/utils/custom_utils.c +++ b/code/sdk/zhihui/utils/custom_utils.c @@ -4574,7 +4574,7 @@ void uapi_cat1_remove_cat1_vote(void) { #ifdef SUPPORT_CAT1_SERVICE uint8_t cnt = pm_veto_get_id_cnt(PM_ID_CAT1); - if (cnt == 1) { + if (cnt > 0) { uapi_pm_remove_sleep_veto(PM_ID_CAT1); } else { // WEARABLE_LOGE(WEARABLE_LOG_MODULE_MAIN_SERVICE,"CAT1 SERVICE MCU has delete pm_id_cat1 vote\r\n"); -- 2.17.1