'FT_SINGLE_UART',
'SUPPORT_CAT1_SERVICE',
'SUPPORT_CAT1_UART_WAKEUP',
+ 'SUPPORT_SLIP_SERVICE_INTERRUPT',
'CONFIG_EFUSE_READ_TO_RAM',
'CUSTOM_UTILS',
# 'SUPPORT_PPP_SERVICE_POLLING',
# 'CONFIG_UART_SUPPORT_DMA',
# ppp interrupt 读取串口 与polling只能开启一个
+ 'SUPPORT_PPP_SERVICE',
'SUPPORT_PPP_SERVICE_INTERRUPT',
'SUPPORT_CAT1_UART_WAKEUP',
#离线日志
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_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"
};
#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)
#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
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 */
/* 定时器相关 */
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; // 最后接收数据时间
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");
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) {
// ⚠️ 更新全局时间戳(供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;
+ }
}
}
}
}
/**
- * @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;
}
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];
} 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
}
/**
}
/**
- * @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))
{
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) {
}
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,
}
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)
{
printf("[SIO] Disabling interrupt mode\n");
+#ifdef USE_SIO_PROCESS_THREAD
// 1. 停止定时器
if (g_sio_timer_running) {
g_sio_timer_running = false;
// 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
{
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) {
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);
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);
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);
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();
}
/**
*/
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");
}
/**
#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
#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
#endif
#ifndef PBUF_POOL_SIZE
-#define PBUF_POOL_SIZE 16
+#define PBUF_POOL_SIZE 128 /* 增加以支持高负载场景,防止 pbuf 耗尽 */
#endif
#if defined (CONFIG_LWIP_FOR_WIFI_SIGMA)
#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
#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
/* 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
/*
#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. */
* 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
/**
/* 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"));
#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};
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 */
#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;
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
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;
}
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;
}
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));
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;
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;
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"));
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);
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",
/* 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);
/* 设置全局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;
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表示没有处理任何数据包
/* 释放锁,避免在 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"));
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));
}
}
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;
+}
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
)
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
}
/**
*/
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
}
*/
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
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");
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)
S_MGPIO22,//ring_pin
0,
S_MGPIO21,//wakemodem_pin
- 0,
+ 1,
#else
PIN_NONE, //bat_pin
1,
${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
)
# 公共头文件路径(供其他模块引用)
--- /dev/null
+# 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请求和流式下载
+
#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"
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,服务器获取
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};
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)
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;
}
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)
{
}
}
}
- uapi_pm_remove_sleep_veto(PM_ID_DEBUG);
+ cat1_api_remove_cat1_app_vote();
return ret;
}
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;
/* 判断是否存在部分文件,计算续传偏移 */
{
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;
}
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);
{
free(header_buf);
HttpClientUnprepare(&client_data);
+#if !LN_HTTP_DOWNLOAD_USE_QUEUE
fclose(fd);
+#endif
return ERRCODE_FAIL;
}
HttpClientSetCustomHeader(&client, header_buf);
{
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;
}
{
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;
{
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;
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);
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)
{
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
{
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通知与资源释放 */
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)
}
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),失败则逐步扩容重试 */
#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
fclose(fd);
#endif
free(save_path);
+#ifdef SUPPORT_CAT1_SERVICE
+ cat1_api_remove_cat1_app_vote();
+#endif
return ERRCODE_FAIL;
}
#endif
HttpClientUnprepare(&client_data);
free(save_path);
+#ifdef SUPPORT_CAT1_SERVICE
+ cat1_api_remove_cat1_app_vote();
+#endif
return ERRCODE_FAIL;
}
HttpClientClse(&client);
HttpClientUnprepare(&client_data);
free(save_path);
+#ifdef SUPPORT_CAT1_SERVICE
+ cat1_api_remove_cat1_app_vote();
+#endif
return ERRCODE_FAIL;
}
HttpClientUnprepare(&client_data);
HttpClientClse(&client);
free(save_path);
+#ifdef SUPPORT_CAT1_SERVICE
+ cat1_api_remove_cat1_app_vote();
+#endif
return ERRCODE_SUCC;
}
#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 /* 语音对话流分片接收 */
#include "ln_api.h"
+#include "ln_http_client.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#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};
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)
{
}
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;
}
// 获取设备角色信息
-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);
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;
}
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;
}
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;
}
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
#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 // 最大路径长度
{
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 */
}
}
+/* 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,
}
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,
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);
}
/* 上报角色表情组下载/删除状态 */
#include "ln_api.h"
+#include "ln_http_client.h"
#include <stdio.h>
#include <stdlib.h>
#include "upg_common_porting.h" /* 使用统一的 UPG_FILE_NAME 路径宏 */
#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
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++) {
(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:
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)
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,
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风格实现的文件下载函数
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};
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;
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; // 视为已完成
}
}
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;
}
{
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;
}
{
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);
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);
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;
}
HttpClientClse(&client);
fclose(fd);
HttpClientUnprepare(&client_data);
+#if defined(SUPPORT_CAT1_SERVICE) || defined(SUPPORT_PPP_SERVICE)
+ cat1_api_keep_wakeup(0);
+#endif
return ret;
}
HttpClientClse(&client);
fclose(fd);
HttpClientUnprepare(&client_data);
+#if defined(SUPPORT_CAT1_SERVICE) || defined(SUPPORT_PPP_SERVICE)
+ cat1_api_keep_wakeup(0);
+#endif
return -1;
}
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;
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;
}
// 后续接收循环
+ // 用于定期喂狗,防止长时间下载导致看门狗超时
+ 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)
{
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;
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;
}
}
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;
#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)
}
}
+/* 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)
}
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;
}
#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)
}
}
+/* 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)
}
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;
}
#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);
+}
#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);
}
#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)
}
}
-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;
}
free(json_body);
if (escaped_theme)
free(escaped_theme);
- free(header_buf);
return ERRCODE_FAIL;
}
int json_len = 0;
}
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;
}
//解析语音聊天响应
#include "ln_api.h"
+#include "ln_http_client.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
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);
}
#include "ln_api.h"
+#include "ln_http_client.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
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 */
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"
"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);
{
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;
}
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;
}
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;
+}
--- /dev/null
+#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;
+}
+
--- /dev/null
+#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 */
+
--- /dev/null
+/**
+ * @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;
+}
+
--- /dev/null
+/**
+ * @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 */
+
--- /dev/null
+/**
+ * @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;
+}
+
--- /dev/null
+/**
+ * @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 */
+
+
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");
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;
#ifdef SUPPORT_CAT1_SERVICE
cat1_api_keep_wakeup(0);
cat1_api_wakeup_cat1(0);
+ cat1_api_remove_cat1_app_vote();
#endif
// 验证下载的文件
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,
{
#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");