chore: migrate project into clean repository

src/framework/CMakeLists.txt

@@ -0,0 +1,8 @@
+listenai_library_named(voice_framework)
+
+listenai_library_sources(
+    voice_msg.c
+    async_task.c
+)
+
+listenai_include_directories(.)

src/framework/async_task.c

@@ -0,0 +1,211 @@
+#include "async_task.h"
+#include "lisa_log.h"
+#include "lisa_mem.h"
+#include "FreeRTOS.h"
+#include "task.h"
+#include "semphr.h"
+#include <string.h>
+
+#define DEFAULT_TASK_NAME "task.async"
+
+struct async_task {
+    char *name;
+    async_task_func_t func;
+    void *user_data;
+    async_task_complete_callback_t callback;
+    uint32_t stack_size;
+    uint32_t priority;
+    TaskHandle_t task_handle;
+    SemaphoreHandle_t mutex;
+    volatile bool should_stop;
+    volatile bool is_running;
+};
+
+static void async_task_thread(void *param)
+{
+    async_task_t *task = (async_task_t *)param;
+
+    if (!task || !task->func) {
+        LOGE("Invalid task");
+        vTaskDelete(NULL);
+        return;
+    }
+
+    xSemaphoreTake(task->mutex, portMAX_DELAY);
+    task->is_running = true;
+    task->should_stop = false;
+    xSemaphoreGive(task->mutex);
+
+    LOGI("Async task started");
+
+    task->func(task->user_data, (bool *)&task->should_stop);
+
+    xSemaphoreTake(task->mutex, portMAX_DELAY);
+    bool was_stopped = task->should_stop;
+    task->is_running = false;
+    task->task_handle = NULL;
+    xSemaphoreGive(task->mutex);
+
+    LOGI("Async task completed, interrupted: %d", was_stopped);
+
+    if (task->callback) {
+        task->callback(task->user_data, !was_stopped, was_stopped);
+    }
+
+    async_task_destroy(task);
+
+    vTaskDelete(NULL);
+}
+
+async_task_t *async_task_create(const char *name, uint32_t stack_size, uint32_t priority, async_task_func_t func,
+                                async_task_complete_callback_t callback, void *user_data)
+{
+    if (!func) {
+        LOGE("Invalid function pointer");
+        return NULL;
+    }
+
+    async_task_t *task = lisa_mem_calloc(1, sizeof(async_task_t));
+    if (!task) {
+        LOGE("Failed to allocate task");
+        return NULL;
+    }
+
+    task->mutex = xSemaphoreCreateMutex();
+    if (!task->mutex) {
+        LOGE("Failed to create mutex");
+        lisa_mem_free(task);
+        return NULL;
+    }
+
+    const char *task_name = name ? name : DEFAULT_TASK_NAME;
+    task->name = lisa_mem_calloc(1, strlen(task_name) + 1);
+    if (!task->name) {
+        LOGE("Failed to allocate task name");
+        vSemaphoreDelete(task->mutex);
+        lisa_mem_free(task);
+        return NULL;
+    }
+    strcpy(task->name, task_name);
+
+    task->func = func;
+    task->user_data = user_data;
+    task->callback = callback;
+    task->stack_size = stack_size > 0 ? stack_size : 2048;
+    task->priority = priority;
+    task->task_handle = NULL;
+    task->should_stop = false;
+    task->is_running = false;
+
+    LOGI("Async task created: %s", task->name);
+
+    return task;
+}
+
+int async_task_start(async_task_t *task)
+{
+    if (!task) {
+        LOGE("Invalid task");
+        return -1;
+    }
+
+    xSemaphoreTake(task->mutex, portMAX_DELAY);
+
+    if (task->is_running) {
+        LOGW("Task is already running");
+        xSemaphoreGive(task->mutex);
+        return -1;
+    }
+
+    BaseType_t ret =
+        xTaskCreate(async_task_thread, task->name, task->stack_size, task, task->priority, &task->task_handle);
+
+    xSemaphoreGive(task->mutex);
+
+    if (ret != pdPASS) {
+        LOGE("Failed to create task thread");
+        return -1;
+    }
+
+    LOGI("Async task started");
+    return 0;
+}
+
+int async_task_stop(async_task_t *task)
+{
+    if (!task) {
+        LOGE("Invalid task");
+        return -1;
+    }
+
+    xSemaphoreTake(task->mutex, portMAX_DELAY);
+
+    if (!task->is_running) {
+        LOGW("Task is not running");
+        xSemaphoreGive(task->mutex);
+        return -1;
+    }
+
+    task->should_stop = true;
+    LOGI("Stop signal sent to task");
+
+    xSemaphoreGive(task->mutex);
+
+    return 0;
+}
+
+bool async_task_is_running(async_task_t *task)
+{
+    if (!task) {
+        return false;
+    }
+
+    xSemaphoreTake(task->mutex, portMAX_DELAY);
+    bool running = task->is_running;
+    xSemaphoreGive(task->mutex);
+
+    return running;
+}
+
+void async_task_destroy(async_task_t *task)
+{
+    if (!task) {
+        return;
+    }
+
+    if (task->is_running) {
+        LOGW("Destroying running task, stopping first");
+        async_task_stop(task);
+
+        TickType_t start_tick = xTaskGetTickCount();
+        const uint32_t timeout_ms = 5000;
+        bool timeout_logged = false;
+
+        while (task->is_running) {
+            vTaskDelay(pdMS_TO_TICKS(10));
+
+            if (!timeout_logged) {
+                TickType_t current_tick = xTaskGetTickCount();
+                uint32_t elapsed_ms = (current_tick - start_tick) * portTICK_PERIOD_MS;
+
+                if (elapsed_ms >= timeout_ms) {
+                    LOGE("Task %s (func: %p) failed to stop after %u ms, still waiting...",
+                         task->name ? task->name : "unknown", task->func, timeout_ms);
+                    timeout_logged = true;
+                }
+            }
+        }
+    }
+
+    if (task->mutex) {
+        vSemaphoreDelete(task->mutex);
+    }
+
+    if (task->name) {
+        lisa_mem_free(task->name);
+    }
+
+    lisa_mem_free(task);
+
+    LOGI("Async task destroyed");
+}

src/framework/async_task.h

@@ -0,0 +1,27 @@
+#ifndef ASYNC_TASK_H
+#define ASYNC_TASK_H
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct async_task async_task_t;
+typedef void (*async_task_func_t)(void *user_data, bool *should_stop);
+typedef void (*async_task_complete_callback_t)(void *user_data, bool completed, bool interrupted);
+
+async_task_t *async_task_create(const char *name, uint32_t stack_size, uint32_t priority, async_task_func_t func,
+                                async_task_complete_callback_t callback, void *user_data);
+
+int async_task_start(async_task_t *task);
+int async_task_stop(async_task_t *task);
+bool async_task_is_running(async_task_t *task);
+void async_task_destroy(async_task_t *task);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/framework/image_url_utils.h

@@ -0,0 +1,67 @@
+#ifndef IMAGE_URL_UTILS_H
+#define IMAGE_URL_UTILS_H
+
+#include <stddef.h>
+#include <stdio.h>
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define IMAGE_OSS_DEFAULT_WIDTH (148)
+
+static inline int build_image_display_url_with_width(const char *input_url,
+                                                     char *output_url,
+                                                     size_t output_size,
+                                                     unsigned int width)
+{
+    char oss_process[128] = {0};
+
+    if (!input_url || !output_url || output_size == 0 || width == 0) {
+        return -1;
+    }
+
+    int p = snprintf(oss_process,
+                     sizeof(oss_process),
+                     "x-oss-process=image/resize,m_pad,w_%u,limit_0,color_000000/quality,q_100/format,jpg",
+                     width);
+    if (p <= 0 || (size_t)p >= sizeof(oss_process)) {
+        return -1;
+    }
+
+    const char *q = strchr(input_url, '?');
+    if (!q) {
+        int n = snprintf(output_url, output_size, "%s?%s", input_url, oss_process);
+        return (n > 0 && (size_t)n < output_size) ? 0 : -1;
+    }
+
+    if (strstr(q + 1, "x-oss-process=") != NULL) {
+        size_t base_len = (size_t)(q - input_url);
+        if (base_len + 1 >= output_size) {
+            return -1;
+        }
+        memcpy(output_url, input_url, base_len);
+        output_url[base_len] = '\0';
+
+        int n = snprintf(output_url + base_len, output_size - base_len, "?%s", oss_process);
+        return (n > 0 && (size_t)n < (output_size - base_len)) ? 0 : -1;
+    }
+
+    int n = snprintf(output_url, output_size, "%s&%s", input_url, oss_process);
+    return (n > 0 && (size_t)n < output_size) ? 0 : -1;
+}
+
+static inline int build_image_display_url(const char *input_url, char *output_url, size_t output_size)
+{
+    return build_image_display_url_with_width(input_url,
+                                              output_url,
+                                              output_size,
+                                              IMAGE_OSS_DEFAULT_WIDTH);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/framework/voice_msg.c

@@ -0,0 +1,225 @@
+#include <assert.h>
+#include <stdint.h>
+#include <string.h>
+#include <stddef.h>
+#include <stdio.h>
+
+#include "FreeRTOS.h"
+#include "task.h"
+#include "semphr.h"
+
+#include "sys_init.h"
+#include "lisa_log.h"
+#include "lisa_typedef.h"
+#include "ebus/ebus.h"
+#include "voice_msg.h"
+#include "sysheap.h"
+
+#define TAG "voice.msg"
+
+static ebus_chn_t *voice_default_chn = NULL;
+
+struct voice_invoke {
+    voice_invoke_worker_t worker;
+    uint32_t data_len;
+    uint8_t data[0];
+};
+
+struct voice_invoke_sync {
+    voice_invoke_sync_worker_t worker;
+    struct voice_invoke_rsp *rsp;
+    uint32_t data_len;
+    uint8_t data[0];
+};
+
+static SemaphoreHandle_t voice_invoke_sync_resp_sem = NULL;
+static SemaphoreHandle_t voice_invoke_sync_lock = NULL;
+
+static void voice_invoke_sumbit_msg_received(void *unused, uint32_t evt, void *data, uint32_t len, void *user_data)
+{
+    struct voice_invoke *invoke = (struct voice_invoke *)data;
+    if (invoke == NULL) {
+        return;
+    }
+
+    LOGI("voice invoke, worker: %p, data: %p, len: %d", invoke->worker, invoke->data, invoke->data_len);
+
+    if (invoke->worker) {
+        invoke->worker(invoke->data, invoke->data_len);
+    }
+}
+
+static void voice_invoke_sync_sumbit_msg_received(void *unused, uint32_t evt, void *data, uint32_t len, void *user_data)
+{
+    struct voice_invoke_sync *invoke = (struct voice_invoke_sync *)data;
+    if (invoke == NULL) {
+        return;
+    }
+
+    LOGI("voice invoke, worker: %p, data: %p, len: %d", invoke->worker, invoke->data, invoke->data_len);
+
+    if (invoke->worker) {
+        invoke->worker(invoke->data, invoke->data_len, invoke->rsp);
+    }
+
+    xSemaphoreGive(voice_invoke_sync_resp_sem);
+}
+
+int voice_invoke(voice_invoke_worker_t worker, void *data, uint32_t len)
+{
+    if (worker == NULL) {
+        return -1;
+    }
+
+    struct voice_invoke *invoke = psram_malloc(sizeof(*invoke) + len);
+    if (invoke == NULL) {
+        return -1;
+    }
+
+    invoke->worker = worker;
+    invoke->data_len = len;
+
+    if (len) {
+        memcpy(invoke->data, data, len);
+    }
+
+    if (voice_msg_pub(VOICE_MSG_INVOKE_SUBMIT, invoke, sizeof(*invoke) + len) != 0) {
+        psram_free(invoke);
+        return -1;
+    }
+
+    return 0;
+}
+
+int voice_invoke_sync(voice_invoke_sync_worker_t worker, void *data, uint32_t len, struct voice_invoke_rsp *rsp,
+                      uint32_t timeout)
+{
+    if (worker == NULL || rsp == NULL) {
+        return -1;
+    }
+
+    struct voice_invoke_sync *invoke_sync = psram_malloc(sizeof(*invoke_sync) + len);
+    if (invoke_sync == NULL) {
+        return -1;
+    }
+
+    invoke_sync->worker = worker;
+    invoke_sync->data_len = len;
+    invoke_sync->rsp = rsp;
+
+    if (len) {
+        memcpy(invoke_sync->data, data, len);
+    }
+
+    BaseType_t r = xSemaphoreTake(voice_invoke_sync_lock, timeout);
+    if (r != pdPASS) {
+        psram_free(invoke_sync);
+        return -1;
+    }
+
+    xSemaphoreTake(voice_invoke_sync_resp_sem, 0);
+    voice_msg_pub(VOICE_MSG_INVOKE_SYNC_SUBMIT, invoke_sync, sizeof(*invoke_sync) + len);
+    r = xSemaphoreTake(voice_invoke_sync_resp_sem, timeout);
+
+    xSemaphoreGive(voice_invoke_sync_lock);
+
+    return r == pdPASS ? 0 : -1;
+}
+
+int voice_msg_init(void)
+{
+    int r;
+    ebus_handle_t *bus;
+    ebus_chn_t *chn;
+
+    r = ebus_init();
+    LOGI("voice_msg_init, ebus_init ret:%d", r);
+    assert(r == 0);
+
+    bus = ebus_create_async("voice.ebus", 128, 32 * 1024, 6);
+    LOGI("voice_msg_init, ebus_create ret:%p", bus);
+    assert(bus);
+
+    voice_default_chn = ebus_chn_create_attach(bus, "voice.ebus.default");
+    LOGI("voice_msg_init, ebus_chn_create_attach ret:%p", voice_default_chn);
+    assert(voice_default_chn);
+
+    voice_invoke_sync_lock = xSemaphoreCreateMutex();
+    assert(voice_invoke_sync_lock);
+
+    voice_invoke_sync_resp_sem = xSemaphoreCreateBinary();
+    assert(voice_invoke_sync_resp_sem);
+
+
+    voice_msg_sub(VOICE_MSG_INVOKE_SUBMIT, voice_invoke_sumbit_msg_received, NULL);
+    voice_msg_sub(VOICE_MSG_INVOKE_SYNC_SUBMIT, voice_invoke_sync_sumbit_msg_received, NULL);
+
+    return 0;
+}
+
+int voice_msg_pub(uint32_t evt, void *data, uint32_t len)
+{
+    return voice_msg_pub_timeout(evt, data, len, LISA_OS_WAIT_FOREVER);
+}
+
+int voice_msg_pub_timeout(uint32_t evt, void *data, uint32_t len, int32_t timeout_ms)
+{
+    ebus_chn_t *chn;
+    int r;
+
+    chn = voice_default_chn;
+    if (chn == NULL) {
+        LOGE("voice msg chn is null, evt:%d", evt);
+        return -1;
+    }
+
+    r = ebus_message_pub_async_timeout(chn, evt, data, len, timeout_ms);
+    if (r != 0) {
+        LOGE("voice msg pub failed, evt:%d", evt);
+        return -1;
+    }
+
+    return 0;
+}
+
+int voice_msg_sub(uint32_t evt, voice_msg_cb_t cb, void *user_data)
+{
+    ebus_chn_t *chn;
+    int r;
+
+    chn = voice_default_chn;
+    if (chn == NULL) {
+        LOGE("voice msg chn is null, evt:%d", evt);
+        return -1;
+    }
+
+    r = ebus_message_subscribe(chn, EBUS_SUBSCRIBER_TYPE_ASYNC, evt, (ebus_chn_cb_t)cb, user_data);
+    if (r != 0) {
+        LOGE("voice msg sub failed, evt:%d", evt);
+        return -1;
+    }
+
+    return 0;
+}
+
+int voice_msg_unsub(uint32_t evt, voice_msg_cb_t cb)
+{
+    ebus_chn_t *chn;
+    int r;
+
+    chn = voice_default_chn;
+    if (chn == NULL) {
+        LOGE("voice msg chn is null, evt:%d", evt);
+        return -1;
+    }
+
+    r = ebus_message_unsubscribe(chn, (ebus_chn_cb_t)cb);
+    if (r != 0) {
+        LOGE("voice msg unsub failed, evt:%d", evt);
+        return -1;
+    }
+
+    return 0;
+}
+
+SYS_INIT(voice_msg_init, SYS_INIT_LEVEL_PRE_APPLICATION, 30);

src/framework/voice_msg.h

@@ -0,0 +1,244 @@
+#ifndef __VOICE_EVT_H__
+#define __VOICE_EVT_H__
+
+#include <stdint.h>
+
+#include "voice_msg_structure.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Domain */
+enum {
+    VOICE_DOMAIN_APPLICATION = 0, /* 由应用程序自行定义 */
+    VOICE_DOMAIN_SYSTEM,
+    VOICE_DOMAIN_INVOKE,
+    VOICE_DOMAIN_POWER,
+    VOICE_DOMAIN_PLATFORM,
+    VOICE_DOMAIN_WIFI,
+    VOICE_DOMAIN_BLE,
+    VOICE_DOMAIN_BUTTON,
+    VOICE_DOMAIN_WAKEUP,
+    VOICE_DOMAIN_CLOUD,
+    VOICE_DOMAIN_PLAYER,
+    VOICE_DOMAIN_RECORD,
+    VOICE_DOMAIN_ALARM,
+    VOICE_DOMAIN_RECOGNIZED,
+    VOICE_DOMAIN_PLAY_CONTROL,
+#ifdef CONFIG_OTA
+    VOICE_DOMAIN_OTA,
+#endif
+    VOICE_DOMAIN_MAX,
+};
+
+#define VOICE_MSG_ID(domain, evt) (((domain) << 16) | (evt))
+#define VOICE_MSG_DOMAIN(msg) ((msg) >> 16)
+#define VOICE_MSG_EVT(msg)    ((msg) & 0xffff)
+
+typedef enum {
+    VOICE_MSG_BUTTON_ACTION_PRESS_DOWN = 0,
+    VOICE_MSG_BUTTON_ACTION_CLICK,
+    VOICE_MSG_BUTTON_ACTION_DOUBLE_CLICK,
+    VOICE_MSG_BUTTON_ACTION_TRIPLE_CLICK,
+    VOICE_MSG_BUTTON_ACTION_QUADRUPLE_CLICK,
+    VOICE_MSG_BUTTON_ACTION_QUINTUPLE_CLICK,
+    VOICE_MSG_BUTTON_ACTION_SEXTUPLE_CLICK,
+    VOICE_MSG_BUTTON_ACTION_SEPTUPLE_CLICK,
+    VOICE_MSG_BUTTON_ACTION_REPEAT_CLICK,
+    VOICE_MSG_BUTTON_ACTION_SHORT_START,
+    VOICE_MSG_BUTTON_ACTION_SHORT_UP,
+    VOICE_MSG_BUTTON_ACTION_LONG_START,
+    VOICE_MSG_BUTTON_ACTION_LONG_UP,
+    VOICE_MSG_BUTTON_ACTION_LONG_HOLD,
+    VOICE_MSG_BUTTON_ACTION_LONG_HOLD_UP,
+    VOICE_MSG_BUTTON_ACTION_UNKNOWN,
+} voice_msg_button_action_t;
+
+typedef struct {
+    uint8_t button_id;
+    voice_msg_button_action_t action;
+} voice_msg_button_evt_t;
+
+struct voice_msg_audio_item {
+    uint8_t playable;
+    char id[32];
+    char name[64];
+} __attribute__((packed));
+
+struct voice_msg_audio_items {
+    uint32_t cnt;
+    struct voice_msg_audio_item items[0];
+} __attribute__((packed));
+
+struct voice_invoke_rsp {
+    int err;
+    uint8_t data[0];
+};
+
+typedef void (*voice_invoke_worker_t)(void *, uint32_t);
+typedef void (*voice_invoke_sync_worker_t)(void *, uint32_t, struct voice_invoke_rsp *);
+
+enum {
+    /* System事件 */
+    VOICE_MSG_SYSTEM_START = VOICE_MSG_ID(VOICE_DOMAIN_SYSTEM, 0),
+    VOICE_MSG_SYSTEM_NETWORK_PROBE_SUCCESS,
+    VOICE_MSG_SYSTEM_NETWORK_PROBE_FAIL,
+    VOICE_MSG_SYSTEM_MAX,
+
+    /* WORKQ */
+    VOICE_MSG_INVOKE_START = VOICE_MSG_ID(VOICE_DOMAIN_INVOKE, 0),
+    /*
+     * 注意: 应用层不要监听INVOKE相关
+     * 如需要代理执行, 请调用voice_invoke接口
+     */
+    VOICE_MSG_INVOKE_SUBMIT,
+    VOICE_MSG_INVOKE_SYNC_SUBMIT,
+
+    /* Power事件 */
+    VOICE_MSG_POWER_START = VOICE_MSG_ID(VOICE_DOMAIN_POWER, 0),
+    VOICE_MSG_POWER_BATTERY_UPDATE,
+    VOICE_MSG_POWER_MAX,
+
+    /* Platform事件 */
+    VOICE_MSG_PLATFORM_START = VOICE_MSG_ID(VOICE_DOMAIN_PLATFORM, 0),
+    VOICE_MSG_PLATFORM_READY = VOICE_MSG_PLATFORM_START,
+    VOICE_MSG_PLATFORM_MAX,
+
+#ifdef CONFIG_OTA
+    /* OTA事件 */
+    VOICE_MSG_OTA_START = VOICE_MSG_ID(VOICE_DOMAIN_OTA, 0),
+    VOICE_MSG_OTA_CHECKING,
+    VOICE_MSG_OTA_UPDATING,
+    VOICE_MSG_OTA_SUCCESSED,
+    VOICE_MSG_OTA_FAILED,
+    VOICE_MSG_OTA_UP_TO_DATE,
+    VOICE_MSG_OTA_MAX,
+#endif
+
+    /* WIFI事件 */
+    VOICE_MSG_WIFI_START = VOICE_MSG_ID(VOICE_DOMAIN_WIFI, 0),
+    VOICE_MSG_WIFI_CONNECTED = VOICE_MSG_WIFI_START,
+    VOICE_MSG_WIFI_DISCONNECTED,
+    VOICE_MSG_WIFI_SCAN_DONE,
+    VOICE_MSG_WIFI_IP_GOT,
+    VOICE_MSG_WIFI_MAX,
+
+    /* BLE事件 */
+    VOICE_MSG_BLE_START = VOICE_MSG_ID(VOICE_DOMAIN_BLE, 0),
+    VOICE_MSG_BLE_CONNECT_DONE = VOICE_MSG_BLE_START,
+    VOICE_MSG_BLE_DISCONNECT_DONE,
+    VOICE_MSG_BLE_SCAN_DONE,
+    VOICE_MSG_BLE_MAX,
+
+    VOICE_MSG_BUTTON_START = VOICE_MSG_ID(VOICE_DOMAIN_BUTTON, 0),
+    VOICE_MSG_BUTTON_CHANGE = VOICE_MSG_BUTTON_START,
+    VOICE_MSG_BUTTON_IMAGE_RECOGNITION,
+    VOICE_MSG_BUTTON_MAX,
+    /* WAKEUP事件 */
+    VOICE_MSG_WAKEUP_START = VOICE_MSG_ID(VOICE_DOMAIN_WAKEUP, 0),
+    VOICE_MSG_WAKEUP_KEYWORD = VOICE_MSG_WAKEUP_START,
+    VOICE_MSG_WAKEUP_COMMAND,
+    VOICE_MSG_WAKEUP_RECOGNIZED_START,
+    VOICE_MSG_WAKEUP_RECOGNIZED_FINISH,
+    VOICE_MSG_WAKEUP_BUTTON,
+    VOICE_MSG_WAKEUP_BUTTON_START,
+    VOICE_MSG_WAKEUP_BUTTON_STOP,
+    VOICE_MSG_WAKEUP_MAX,
+
+    /* LSChat事件 */
+    VOICE_MSG_CLOUD_START = VOICE_MSG_ID(VOICE_DOMAIN_CLOUD, 0),
+    VOICE_MSG_CLOUD_CONNECTING = VOICE_MSG_CLOUD_START,
+    VOICE_MSG_CLOUD_CONNECTED,
+    VOICE_MSG_CLOUD_DISCONNECTED,
+    VOICE_MSG_CLOUD_RECONNECTING,
+    VOICE_MSG_CLOUD_ERROR,
+    VOICE_MSG_CLOUD_CLOUD_AUTH_FAILED,
+    VOICE_MSG_CLOUD_CLOUD_AUTH_SUCCESS,
+    VOICE_MSG_CLOUD_SESSION_STARTING,
+    VOICE_MSG_CLOUD_SESSION_STARTED,
+    VOICE_MSG_CLOUD_SESSION_FINISHED,
+    VOICE_MSG_CLOUD_TTS_URL,
+    VOICE_MSG_CLOUD_IAT_START,
+    VOICE_MSG_CLOUD_IAT_UPDATE,
+    VOICE_MSG_CLOUD_IAT_END,
+    VOICE_MSG_CLOUD_TTS_TEXT_START,
+    VOICE_MSG_CLOUD_TTS_TEXT_UPDATE,
+    VOICE_MSG_CLOUD_TTS_TEXT_END,
+    VOICE_MSG_CLOUD_MCP,
+    VOICE_MSG_CLOUD_MCP_CALL_RESP, /* char * */
+    VOICE_MSG_CLOUD_AUDIO_URL,     /* char * */
+    VOICE_MSG_CLOUD_AUDIO_ITEM,    /* struct voice_msg_audio_items * */
+    VOICE_MSG_CLOUD_RECOGNIZED_COMMAND,
+    VOICE_MSG_CLOUD_RECOGNIZED_COMMAND_WITH_TIMER,/*定时控制命令*/
+    VOICE_MSG_CLOUD_VAD,
+    VOICE_MSG_CLOUD_EMOJI,
+    VOICE_MSG_CLOUD_MCP_EMOJI,
+    VOICE_MSG_CLOUD_MCP_LOADING,
+    VOICE_MSG_CLOUD_MCP_CHAT_EXIT,
+    VOICE_MSG_CLOUD_MCP_IMAGE_RECOGNITION, /* char * */
+    VOICE_MSG_CLOUD_MCP_IMAGE_URL,         /* char * */
+    VOICE_MSG_CLOUD_ROLE_SETTING_QRCODE,
+    VOICE_MSG_CLOUD_VPR_INFO,
+    VOICE_MSG_CLOUD_VPR_FEATURE,
+    VOICE_MSG_CLOUD_STANDBY_TEXTS, /* char * banner json */
+    VOICE_MSG_CLOUD_SHOW_QRCODE,   /* char * json with url, message, err_code */
+    VOICE_MSG_CLOUD_OPEN_INFO,
+    VOICE_MSG_CLOUD_MAX,
+
+    /* Player事件 */
+    VOICE_MSG_PLAYER_START = VOICE_MSG_ID(VOICE_DOMAIN_PLAYER, 0),
+    VOICE_MSG_PLAYER_TTS_PLAYING,
+    VOICE_MSG_PLAYER_TTS_PAUSED,
+    VOICE_MSG_PLAYER_TTS_STOPED,
+    VOICE_MSG_PLAYER_MAX,
+
+    /* Record事件 */
+    VOICE_MSG_RECORD_START = VOICE_MSG_ID(VOICE_DOMAIN_RECORD, 0),
+    VOICE_MSG_RECORD_MAX,
+
+    /* Alarm事件 */
+    VOICE_MSG_ALARM_START = VOICE_MSG_ID(VOICE_DOMAIN_ALARM, 0),
+    VOICE_MSG_ALARM_TRIGGER,
+    VOICE_MSG_ALARM_CREATE,
+    VOICE_MSG_ALARM_DELETE,
+    VOICE_MSG_ALARM_QUERY,
+    VOICE_MSG_ALARM_MAX,
+
+    /*命令词处理事件*/
+    VOICE_MSG_RECOGNIZED_START = VOICE_MSG_ID(VOICE_DOMAIN_RECOGNIZED, 0),
+    VOICE_MSG_RECOGNIZED_ONLINE_COMMAND = VOICE_MSG_RECOGNIZED_START,
+    VOICE_MSG_RECOGNIZED_OFFLINE_COMMAND,
+    VOICE_MSG_RECOGNIZED_SESSION_FINISH,
+    VOICE_MSG_RECOGNIZED_MAX,
+
+    /* PlayControl事件 */
+    VOICE_MSG_PLAY_CONTROL_START = VOICE_MSG_ID(VOICE_DOMAIN_PLAY_CONTROL, 0),
+    VOICE_MSG_PLAY_CONTROL_PLAY,
+    VOICE_MSG_PLAY_CONTROL_PAUSE,
+    VOICE_MSG_PLAY_CONTROL_NEXT,
+    VOICE_MSG_PLAY_CONTROL_PREVIOUS,
+    VOICE_MSG_PLAY_CONTROL_REPLAY,
+    VOICE_MSG_PLAY_CONTROL_MAX,
+};
+
+struct voice_msg_wakeup {
+    char keyword[64];
+};
+
+typedef void (*voice_msg_cb_t)(void *unused, uint32_t msg_id, void *data, uint32_t len, void *user_data);
+
+int voice_msg_init(void);
+int voice_msg_pub(uint32_t msg_id, void *data, uint32_t len);
+int voice_msg_pub_timeout(uint32_t msg_id, void *data, uint32_t len, int32_t timeout_ms);
+int voice_msg_sub(uint32_t msg_id, voice_msg_cb_t cb, void *user_data);
+int voice_msg_unsub(uint32_t msg_id, voice_msg_cb_t cb);
+
+int voice_invoke(voice_invoke_worker_t worker, void *data, uint32_t len);
+int voice_invoke_sync(voice_invoke_sync_worker_t worker, void *data, uint32_t len, struct voice_invoke_rsp *rsp,
+                      uint32_t timeout);
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/framework/voice_msg_structure.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+typedef struct{
+    char id[40];
+    char name[64];
+}voice_msg_cloud_mcp_context_t;
+
+typedef struct{
+    voice_msg_cloud_mcp_context_t context;
+    char command[32];
+}voice_msg_cloud_recognized_command_t;
+
+typedef struct{
+    voice_msg_cloud_mcp_context_t context;
+    char cmd[64];
+    char time[32];
+}voice_msg_cloud_recognition_cmd_timer_t;
+
+typedef enum {
+    VOICE_MSG_BATTERY_STATUS_NO_BATTERY = 0,
+    VOICE_MSG_BATTERY_STATUS_NOT_CONNECT,
+    VOICE_MSG_BATTERY_STATUS_CHARGING,
+    VOICE_MSG_BATTERY_STATUS_CHARGE_DONE,
+    VOICE_MSG_BATTERY_STATUS_UNKNOWN,
+} voice_msg_battery_status_t;
+
+typedef struct {
+    uint8_t level;  /* 0-100 */
+    uint8_t status; /* voice_msg_battery_status_t */
+} voice_msg_battery_info_t;
+
+
+#ifdef __cplusplus
+}
+#endif