lwip 优化TCP_WND 2731/target/1
author孙春阳 <snickersun@163.com>
Fri, 7 Nov 2025 23:35:39 +0000 (07:35 +0800)
committer孙春阳 <snickersun@163.com>
Fri, 7 Nov 2025 23:35:39 +0000 (07:35 +0800)
下载刷新进度条优化
sio统计 打印信息优化
sse超时优化
http,httpdownload 统一接口,统一调配功耗方便

34 files changed:
code/sdk/build/config/target_config/brandy/config.py
code/sdk/middleware/chips/brandy/pm/include/pm_definition.h
code/sdk/middleware/chips/brandy/pm/pm.c
code/sdk/open_source/openharmony/third_party/lwip/lwip_adapter/liteos/src/arch/sio.c
code/sdk/open_source/openharmony/third_party/lwip/lwip_adapter/liteos/src/include/lwip/lwipopts_default.h
code/sdk/open_source/openharmony/third_party/lwip/lwip_v2.1.3/src/apps/altcp_tls/altcp_tls_mbedtls.c
code/sdk/open_source/openharmony/third_party/lwip/lwip_v2.1.3/src/netif/slipif.c
code/sdk/zhihui/4g/cat1Service/CMakeLists.txt
code/sdk/zhihui/4g/cat1Service/Service/cat1_utils.c
code/sdk/zhihui/4g/cat1Service/include/cat1_porting.h
code/sdk/zhihui/4gTest/cat1_porting.c
code/sdk/zhihui/leiniao/imsl_ln/CMakeLists.txt
code/sdk/zhihui/leiniao/imsl_ln/HTTP_CLIENT_USAGE.md [new file with mode: 0644]
code/sdk/zhihui/leiniao/imsl_ln/ln_api.c
code/sdk/zhihui/leiniao/imsl_ln/ln_api.h
code/sdk/zhihui/leiniao/imsl_ln/ln_api_device_info.c
code/sdk/zhihui/leiniao/imsl_ln/ln_api_emoji.c
code/sdk/zhihui/leiniao/imsl_ln/ln_api_ota.c
code/sdk/zhihui/leiniao/imsl_ln/ln_api_speech_chat.c
code/sdk/zhihui/leiniao/imsl_ln/ln_api_story_choose.c
code/sdk/zhihui/leiniao/imsl_ln/ln_api_story_exit.c
code/sdk/zhihui/leiniao/imsl_ln/ln_api_story_finish.c
code/sdk/zhihui/leiniao/imsl_ln/ln_api_story_random.c
code/sdk/zhihui/leiniao/imsl_ln/ln_api_timeline_activities.c
code/sdk/zhihui/leiniao/imsl_ln/ln_api_token.c
code/sdk/zhihui/leiniao/imsl_ln/ln_file_write_queue.c [new file with mode: 0644]
code/sdk/zhihui/leiniao/imsl_ln/ln_file_write_queue.h [new file with mode: 0644]
code/sdk/zhihui/leiniao/imsl_ln/ln_http_client.c [new file with mode: 0644]
code/sdk/zhihui/leiniao/imsl_ln/ln_http_client.h [new file with mode: 0644]
code/sdk/zhihui/leiniao/imsl_ln/ln_http_download_client.c [new file with mode: 0644]
code/sdk/zhihui/leiniao/imsl_ln/ln_http_download_client.h [new file with mode: 0644]
code/sdk/zhihui/ppp/src/ppp_cat1_api.c
code/sdk/zhihui/services/gnss/src/gnss_http_server.c
code/sdk/zhihui/utils/custom_utils.c

index 495c4a2..867f83b 100644 (file)
@@ -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',
             #离线日志
index dc8745e..9c217aa 100644 (file)
@@ -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,//血压
index 1ab7b5d..0e04767 100644 (file)
@@ -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"
 };
index b94f2a2..ca84b21 100644 (file)
@@ -49,6 +49,9 @@
 #include <stdlib.h>
 #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");
 }
 
 /**
index 0ec4bb5..20f7b8c 100644 (file)
@@ -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
 
 /**
index 47d5d22..1518b48 100644 (file)
@@ -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"));
index a8a09af..e0a1ac9 100644 (file)
@@ -75,6 +75,9 @@
 #include <los_task.h>
 #include <los_typedef.h>
 #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;
+}
index 691a92a..53293b8 100644 (file)
@@ -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    
 )
index 74ef96d..028f29b 100644 (file)
@@ -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
 
 }
 
index 6056377..a87d827 100644 (file)
@@ -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
index 37ce8d1..07fcafd 100644 (file)
@@ -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,
index 2db97e4..cdf3820 100644 (file)
@@ -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 (file)
index 0000000..407c6d6
--- /dev/null
@@ -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 <stdlib.h>
+#include <string.h>
+
+/* 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 <stdlib.h>
+#include <string.h>
+
+/* 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 <stdio.h>
+
+/* 数据块处理上下文 */
+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 <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* 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 <stdio.h>
+#include <stdlib.h>
+
+/* 数据块处理上下文 */
+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请求和流式下载
+
index 23ad08d..741a8c7 100644 (file)
@@ -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 */
 #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;
 }
 
index 1d89c15..891c471 100644 (file)
@@ -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           /* 语音对话流分片接收 */
index f43bfb2..d9767c6 100644 (file)
@@ -1,4 +1,5 @@
 #include "ln_api.h"
+#include "ln_http_client.h"
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
@@ -6,6 +7,10 @@
 #include <cJSON.h>
 #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 : "<unknown>",
                       (message && cJSON_IsString(message)) ? message->valuestring : "<none>");
-
         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
index 227ff2e..6bea265 100644 (file)
@@ -1,4 +1,5 @@
 #include "ln_api.h"
+#include "ln_http_client.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <dirent.h>
 #include "custom_utils.h"
 #include <sys/time.h>
+/* 使用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);
 }
 
 /* 上报角色表情组下载/删除状态 */
index f394b39..7d916b8 100644 (file)
@@ -1,4 +1,5 @@
 #include "ln_api.h"
+#include "ln_http_client.h"
 #include <stdio.h>
 #include <stdlib.h>
 #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;
index a7d9829..4811079 100644 (file)
@@ -1,5 +1,8 @@
 #include "ln_api.h"
+#include "ln_http_download_client.h"
 #include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 
 /* 读取整个文件到内存,返回缓冲区和长度;需调用者 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;
 }
index 98c3a6b..fff4bf8 100644 (file)
@@ -1,5 +1,8 @@
 #include "ln_api.h"
+#include "ln_http_download_client.h"
 #include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 
 /* 读取整个文件到内存,返回缓冲区和长度;需调用者 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;
 }
index 483e203..1b32e21 100644 (file)
@@ -1,71 +1,82 @@
 #include "ln_api.h"
+#include "ln_http_client.h"
 #include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 
-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);
+}
index 7c9a79c..d78e323 100644 (file)
@@ -1,69 +1,78 @@
 #include "ln_api.h"
+#include "ln_http_client.h"
 #include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 
-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);
 }
index 727f93d..0d900dd 100644 (file)
@@ -1,6 +1,8 @@
 #include "ln_api.h"
+#include "ln_http_download_client.h"
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #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;
 }
 
 //解析语音聊天响应
index d6b125b..722c617 100644 (file)
@@ -1,4 +1,5 @@
 #include "ln_api.h"
+#include "ln_http_client.h"
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
@@ -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);
 }
 
 
index 898b952..a1a444a 100644 (file)
@@ -1,4 +1,5 @@
 #include "ln_api.h"
+#include "ln_http_client.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -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 (file)
index 0000000..fd4a41c
--- /dev/null
@@ -0,0 +1,544 @@
+#include "ln_file_write_queue.h"
+#include "wearable_log.h"
+#include <osal_msgqueue.h>
+#include <thread_init.h>
+#include <soc_osal.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdbool.h>
+#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 (file)
index 0000000..9907eae
--- /dev/null
@@ -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 <stdio.h>
+
+/* 文件写入状态 */
+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 (file)
index 0000000..532c2bc
--- /dev/null
@@ -0,0 +1,247 @@
+/**
+ * @file ln_http_client.c
+ * @brief 统一的HTTP客户端实现
+ */
+
+#include "ln_http_client.h"
+#include "ln_api.h"
+#include "errcode.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#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 (file)
index 0000000..903bbb3
--- /dev/null
@@ -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 <stdint.h>
+#include <stdbool.h>
+
+/* 错误码定义 */
+#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 (file)
index 0000000..1b2d308
--- /dev/null
@@ -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 <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#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 (file)
index 0000000..05a039c
--- /dev/null
@@ -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 <stdint.h>
+#include <stdbool.h>
+#include <stddef.h>
+
+// 复用统一接口的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 */
+
+
index 28b4d8f..6747d6c 100644 (file)
@@ -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;
index 29e06e0..46c7eea 100644 (file)
@@ -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, 
index 18e15af..5a91bd5 100644 (file)
@@ -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");