add some code

main/display/display.cc

@@ -0,0 +1,258 @@
+#include <esp_log.h>
+#include <esp_err.h>
+#include <string>
+#include <cstdlib>
+#include <cstring>
+#include <font_awesome.h>
+
+#include "display.h"
+#include "board.h"
+#include "application.h"
+#include "audio_codec.h"
+#include "settings.h"
+#include "assets/lang_config.h"
+
+#define TAG "Display"
+
+Display::Display() {
+    // Notification timer
+    esp_timer_create_args_t notification_timer_args = {
+        .callback = [](void *arg) {
+            Display *display = static_cast<Display*>(arg);
+            DisplayLockGuard lock(display);
+            lv_obj_add_flag(display->notification_label_, LV_OBJ_FLAG_HIDDEN);
+            lv_obj_remove_flag(display->status_label_, LV_OBJ_FLAG_HIDDEN);
+        },
+        .arg = this,
+        .dispatch_method = ESP_TIMER_TASK,
+        .name = "notification_timer",
+        .skip_unhandled_events = false,
+    };
+    ESP_ERROR_CHECK(esp_timer_create(&notification_timer_args, &notification_timer_));
+
+    // Create a power management lock
+    auto ret = esp_pm_lock_create(ESP_PM_APB_FREQ_MAX, 0, "display_update", &pm_lock_);
+    if (ret == ESP_ERR_NOT_SUPPORTED) {
+        ESP_LOGI(TAG, "Power management not supported");
+    } else {
+        ESP_ERROR_CHECK(ret);
+    }
+}
+
+Display::~Display() {
+    if (notification_timer_ != nullptr) {
+        esp_timer_stop(notification_timer_);
+        esp_timer_delete(notification_timer_);
+    }
+
+    if (network_label_ != nullptr) {
+        lv_obj_del(network_label_);
+        lv_obj_del(notification_label_);
+        lv_obj_del(status_label_);
+        lv_obj_del(mute_label_);
+        lv_obj_del(battery_label_);
+        lv_obj_del(emotion_label_);
+    }
+    if( low_battery_popup_ != nullptr ) {
+        lv_obj_del(low_battery_popup_);
+    }
+    if (pm_lock_ != nullptr) {
+        esp_pm_lock_delete(pm_lock_);
+    }
+}
+
+void Display::SetStatus(const char* status) {
+    DisplayLockGuard lock(this);
+    if (status_label_ == nullptr) {
+        return;
+    }
+    lv_label_set_text(status_label_, status);
+    lv_obj_remove_flag(status_label_, LV_OBJ_FLAG_HIDDEN);
+    lv_obj_add_flag(notification_label_, LV_OBJ_FLAG_HIDDEN);
+
+    last_status_update_time_ = std::chrono::system_clock::now();
+}
+
+void Display::ShowNotification(const std::string &notification, int duration_ms) {
+    ShowNotification(notification.c_str(), duration_ms);
+}
+
+void Display::ShowNotification(const char* notification, int duration_ms) {
+    DisplayLockGuard lock(this);
+    if (notification_label_ == nullptr) {
+        return;
+    }
+    lv_label_set_text(notification_label_, notification);
+    lv_obj_remove_flag(notification_label_, LV_OBJ_FLAG_HIDDEN);
+    lv_obj_add_flag(status_label_, LV_OBJ_FLAG_HIDDEN);
+
+    esp_timer_stop(notification_timer_);
+    ESP_ERROR_CHECK(esp_timer_start_once(notification_timer_, duration_ms * 1000));
+}
+
+void Display::UpdateStatusBar(bool update_all) {
+    auto& app = Application::GetInstance();
+    auto& board = Board::GetInstance();
+    auto codec = board.GetAudioCodec();
+
+    // Update mute icon
+    {
+        DisplayLockGuard lock(this);
+        if (mute_label_ == nullptr) {
+            return;
+        }
+
+        // 如果静音状态改变，则更新图标
+        if (codec->output_volume() == 0 && !muted_) {
+            muted_ = true;
+            lv_label_set_text(mute_label_, FONT_AWESOME_VOLUME_XMARK);
+        } else if (codec->output_volume() > 0 && muted_) {
+            muted_ = false;
+            lv_label_set_text(mute_label_, "");
+        }
+    }
+
+    // Update time
+    if (app.GetDeviceState() == kDeviceStateIdle) {
+        if (last_status_update_time_ + std::chrono::seconds(10) < std::chrono::system_clock::now()) {
+            // Set status to clock "HH:MM"
+            time_t now = time(NULL);
+            struct tm* tm = localtime(&now);
+            // Check if the we have already set the time
+            if (tm->tm_year >= 2025 - 1900) {
+                char time_str[16];
+                strftime(time_str, sizeof(time_str), "%H:%M  ", tm);
+                SetStatus(time_str);
+            } else {
+                ESP_LOGW(TAG, "System time is not set, tm_year: %d", tm->tm_year);
+            }
+        }
+    }
+
+    esp_pm_lock_acquire(pm_lock_);
+    // 更新电池图标
+    int battery_level;
+    bool charging, discharging;
+    const char* icon = nullptr;
+    if (board.GetBatteryLevel(battery_level, charging, discharging)) {
+        if (charging) {
+            icon = FONT_AWESOME_BATTERY_BOLT;
+        } else {
+            const char* levels[] = {
+                FONT_AWESOME_BATTERY_EMPTY, // 0-19%
+                FONT_AWESOME_BATTERY_QUARTER,    // 20-39%
+                FONT_AWESOME_BATTERY_HALF,    // 40-59%
+                FONT_AWESOME_BATTERY_THREE_QUARTERS,    // 60-79%
+                FONT_AWESOME_BATTERY_FULL, // 80-99%
+                FONT_AWESOME_BATTERY_FULL, // 100%
+            };
+            icon = levels[battery_level / 20];
+        }
+        DisplayLockGuard lock(this);
+        if (battery_label_ != nullptr && battery_icon_ != icon) {
+            battery_icon_ = icon;
+            lv_label_set_text(battery_label_, battery_icon_);
+        }
+
+        if (low_battery_popup_ != nullptr) {
+            if (strcmp(icon, FONT_AWESOME_BATTERY_EMPTY) == 0 && discharging) {
+                if (lv_obj_has_flag(low_battery_popup_, LV_OBJ_FLAG_HIDDEN)) { // 如果低电量提示框隐藏，则显示
+                    lv_obj_remove_flag(low_battery_popup_, LV_OBJ_FLAG_HIDDEN);
+                    app.PlaySound(Lang::Sounds::OGG_LOW_BATTERY);
+                }
+            } else {
+                // Hide the low battery popup when the battery is not empty
+                if (!lv_obj_has_flag(low_battery_popup_, LV_OBJ_FLAG_HIDDEN)) { // 如果低电量提示框显示，则隐藏
+                    lv_obj_add_flag(low_battery_popup_, LV_OBJ_FLAG_HIDDEN);
+                }
+            }
+        }
+    }
+
+    // 每 10 秒更新一次网络图标
+    static int seconds_counter = 0;
+    if (update_all || seconds_counter++ % 10 == 0) {
+        // 升级固件时，不读取 4G 网络状态，避免占用 UART 资源
+        auto device_state = Application::GetInstance().GetDeviceState();
+        static const std::vector<DeviceState> allowed_states = {
+            kDeviceStateIdle,
+            kDeviceStateStarting,
+            kDeviceStateWifiConfiguring,
+            kDeviceStateListening,
+            kDeviceStateActivating,
+        };
+        if (std::find(allowed_states.begin(), allowed_states.end(), device_state) != allowed_states.end()) {
+            icon = board.GetNetworkStateIcon();
+            if (network_label_ != nullptr && icon != nullptr && network_icon_ != icon) {
+                DisplayLockGuard lock(this);
+                network_icon_ = icon;
+                lv_label_set_text(network_label_, network_icon_);
+            }
+        }
+    }
+
+    esp_pm_lock_release(pm_lock_);
+}
+
+
+void Display::SetEmotion(const char* emotion) {
+    const char* utf8 = font_awesome_get_utf8(emotion);
+    if (utf8 != nullptr) {
+        SetIcon(utf8);
+    } else {
+        SetIcon(FONT_AWESOME_NEUTRAL);
+    }
+}
+
+void Display::SetIcon(const char* icon) {
+    DisplayLockGuard lock(this);
+    if (emotion_label_ == nullptr) {
+        return;
+    }
+    lv_label_set_text(emotion_label_, icon);
+}
+
+void Display::SetPreviewImage(const lv_img_dsc_t* image) {
+    // Do nothing
+}
+
+void Display::SetChatMessage(const char* role, const char* content) {
+    DisplayLockGuard lock(this);
+    if (chat_message_label_ == nullptr) {
+        return;
+    }
+    lv_label_set_text(chat_message_label_, content);
+}
+
+void Display::SetMusicInfo(const char* song_name) {
+    // 默认实现：对于非微信模式，将歌名显示在聊天消息标签中
+    DisplayLockGuard lock(this);
+    if (chat_message_label_ == nullptr) {
+        return;
+    }
+    if (song_name != nullptr && strlen(song_name) > 0) {
+        std::string music_text = "";
+        music_text += song_name;
+        lv_label_set_text(chat_message_label_, music_text.c_str());
+        SetIcon(FONT_AWESOME_MUSIC);
+    } else {
+        lv_label_set_text(chat_message_label_, "");
+        SetIcon(FONT_AWESOME_NEUTRAL);
+    }
+}
+
+void Display::SetTheme(const std::string& theme_name) {
+    current_theme_name_ = theme_name;
+    Settings settings("display", true);
+    settings.SetString("theme", theme_name);
+}
+
+void Display::SetPowerSaveMode(bool on) {
+    if (on) {
+        SetChatMessage("system", "");
+        SetEmotion("sleepy");
+    } else {
+        SetChatMessage("system", "");
+        SetEmotion("neutral");
+    }
+}

main/display/display.h

@@ -0,0 +1,93 @@
+#ifndef DISPLAY_H
+#define DISPLAY_H
+
+#include <lvgl.h>
+#include <esp_timer.h>
+#include <esp_log.h>
+#include <esp_pm.h>
+
+#include <string>
+#include <chrono>
+
+struct DisplayFonts {
+    const lv_font_t* text_font = nullptr;
+    const lv_font_t* icon_font = nullptr;
+    const lv_font_t* emoji_font = nullptr;
+};
+
+class Display {
+public:
+    Display();
+    virtual ~Display();
+
+    virtual void SetStatus(const char* status);
+    virtual void ShowNotification(const char* notification, int duration_ms = 3000);
+    virtual void ShowNotification(const std::string &notification, int duration_ms = 3000);
+    virtual void SetEmotion(const char* emotion);
+    virtual void SetChatMessage(const char* role, const char* content);
+    virtual void SetMusicInfo(const char* song_name);
+    virtual void SetIcon(const char* icon);
+    virtual void SetPreviewImage(const lv_img_dsc_t* image);
+    virtual void SetTheme(const std::string& theme_name);
+    virtual std::string GetTheme() { return current_theme_name_; }
+    virtual void UpdateStatusBar(bool update_all = false);
+    virtual void SetPowerSaveMode(bool on);
+
+    inline int width() const { return width_; }
+    inline int height() const { return height_; }
+
+protected:
+    int width_ = 0;
+    int height_ = 0;
+    
+    esp_pm_lock_handle_t pm_lock_ = nullptr;
+    lv_display_t *display_ = nullptr;
+
+    lv_obj_t *emotion_label_ = nullptr;
+    lv_obj_t *network_label_ = nullptr;
+    lv_obj_t *status_label_ = nullptr;
+    lv_obj_t *notification_label_ = nullptr;
+    lv_obj_t *mute_label_ = nullptr;
+    lv_obj_t *battery_label_ = nullptr;
+    lv_obj_t* chat_message_label_ = nullptr;
+    lv_obj_t* low_battery_popup_ = nullptr;
+    lv_obj_t* low_battery_label_ = nullptr;
+    
+    const char* battery_icon_ = nullptr;
+    const char* network_icon_ = nullptr;
+    bool muted_ = false;
+    std::string current_theme_name_;
+
+    std::chrono::system_clock::time_point last_status_update_time_;
+    esp_timer_handle_t notification_timer_ = nullptr;
+
+    friend class DisplayLockGuard;
+    virtual bool Lock(int timeout_ms = 0) = 0;
+    virtual void Unlock() = 0;
+};
+
+
+class DisplayLockGuard {
+public:
+    DisplayLockGuard(Display *display) : display_(display) {
+        if (!display_->Lock(30000)) {
+            ESP_LOGE("Display", "Failed to lock display");
+        }
+    }
+    ~DisplayLockGuard() {
+        display_->Unlock();
+    }
+
+private:
+    Display *display_;
+};
+
+class NoDisplay : public Display {
+private:
+    virtual bool Lock(int timeout_ms = 0) override {
+        return true;
+    }
+    virtual void Unlock() override {}
+};
+
+#endif

main/display/esplog_display.cc

@@ -0,0 +1,44 @@
+#include "esplog_display.h"
+
+#include "esp_log.h"
+
+#define TAG "EspLogDisplay"
+
+
+EspLogDisplay::EspLogDisplay()
+{}
+
+EspLogDisplay::~EspLogDisplay()
+{}
+
+void EspLogDisplay::SetStatus(const char* status)
+{
+    ESP_LOGW(TAG, "SetStatus: %s", status);
+}
+
+void EspLogDisplay::ShowNotification(const char* notification, int duration_ms)
+{
+    ESP_LOGW(TAG, "ShowNotification: %s", notification);
+}
+void EspLogDisplay::ShowNotification(const std::string &notification, int duration_ms) 
+{ 
+    ShowNotification(notification.c_str(), duration_ms); 
+}
+
+
+void EspLogDisplay::SetEmotion(const char* emotion)
+{
+    ESP_LOGW(TAG, "SetEmotion: %s", emotion);
+}
+
+void EspLogDisplay::SetIcon(const char* icon)
+{
+    ESP_LOGW(TAG, "SetIcon: %s", icon);
+}
+
+void EspLogDisplay::SetChatMessage(const char* role, const char* content)
+{
+    ESP_LOGW(TAG, "Role:%s", role);
+    ESP_LOGW(TAG, "     %s", content);
+}
+

main/display/esplog_display.h

@@ -0,0 +1,28 @@
+#ifndef ESPLOG_DISPLAY_H_
+#define ESPLOG_DISPLAY_H_
+
+#include "display.h"
+
+#include <string>
+
+class EspLogDisplay : public Display { 
+public:
+    EspLogDisplay();
+    ~EspLogDisplay();
+
+    virtual void SetStatus(const char* status);
+    virtual void ShowNotification(const char* notification, int duration_ms = 3000);
+    virtual void ShowNotification(const std::string &notification, int duration_ms = 3000);
+    virtual void SetEmotion(const char* emotion) override;
+    virtual void SetChatMessage(const char* role, const char* content) override; 
+    virtual void SetIcon(const char* icon) override;
+    virtual inline void SetPreviewImage(const lv_img_dsc_t* image) override {}
+    virtual inline void SetTheme(const std::string& theme_name) override {}
+    virtual inline void UpdateStatusBar(bool update_all = false) override {}
+
+protected:
+    virtual inline bool Lock(int timeout_ms = 0) override { return true; } 
+    virtual inline void Unlock() override {}
+};
+
+#endif

main/display/lcd_display.h

@@ -0,0 +1,106 @@
+#ifndef LCD_DISPLAY_H
+#define LCD_DISPLAY_H
+
+#include "display.h"
+
+#include <esp_lcd_panel_io.h>
+#include <esp_lcd_panel_ops.h>
+#include <font_emoji.h>
+
+#include <atomic>
+
+// Theme color structure
+struct ThemeColors {
+    lv_color_t background;
+    lv_color_t text;
+    lv_color_t chat_background;
+    lv_color_t user_bubble;
+    lv_color_t assistant_bubble;
+    lv_color_t system_bubble;
+    lv_color_t system_text;
+    lv_color_t border;
+    lv_color_t low_battery;
+};
+
+
+class LcdDisplay : public Display {
+protected:
+    esp_lcd_panel_io_handle_t panel_io_ = nullptr;
+    esp_lcd_panel_handle_t panel_ = nullptr;
+    
+    lv_draw_buf_t draw_buf_;
+    lv_obj_t* status_bar_ = nullptr;
+    lv_obj_t* content_ = nullptr;
+    lv_obj_t* container_ = nullptr;
+    lv_obj_t* side_bar_ = nullptr;
+    lv_obj_t* preview_image_ = nullptr;
+
+    DisplayFonts fonts_;
+    ThemeColors current_theme_;
+
+    void SetupUI();
+    virtual bool Lock(int timeout_ms = 0) override;
+    virtual void Unlock() override;
+
+protected:
+    // 添加protected构造函数
+    LcdDisplay(esp_lcd_panel_io_handle_t panel_io, esp_lcd_panel_handle_t panel, DisplayFonts fonts, int width, int height);
+    
+public:
+    ~LcdDisplay();
+    virtual void SetEmotion(const char* emotion) override;
+    virtual void SetIcon(const char* icon) override;
+    virtual void SetPreviewImage(const lv_img_dsc_t* img_dsc) override;
+#if CONFIG_USE_WECHAT_MESSAGE_STYLE
+    virtual void SetChatMessage(const char* role, const char* content) override; 
+#endif  
+
+    // Add theme switching function
+    virtual void SetTheme(const std::string& theme_name) override;
+};
+
+// RGB LCD显示器
+class RgbLcdDisplay : public LcdDisplay {
+public:
+    RgbLcdDisplay(esp_lcd_panel_io_handle_t panel_io, esp_lcd_panel_handle_t panel,
+                  int width, int height, int offset_x, int offset_y,
+                  bool mirror_x, bool mirror_y, bool swap_xy,
+                  DisplayFonts fonts);
+};
+
+// MIPI LCD显示器
+class MipiLcdDisplay : public LcdDisplay {
+public:
+    MipiLcdDisplay(esp_lcd_panel_io_handle_t panel_io, esp_lcd_panel_handle_t panel,
+                   int width, int height, int offset_x, int offset_y,
+                   bool mirror_x, bool mirror_y, bool swap_xy,
+                   DisplayFonts fonts);
+};
+
+// // SPI LCD显示器
+class SpiLcdDisplay : public LcdDisplay {
+public:
+    SpiLcdDisplay(esp_lcd_panel_io_handle_t panel_io, esp_lcd_panel_handle_t panel,
+                  int width, int height, int offset_x, int offset_y,
+                  bool mirror_x, bool mirror_y, bool swap_xy,
+                  DisplayFonts fonts);
+};
+
+// QSPI LCD显示器
+class QspiLcdDisplay : public LcdDisplay {
+public:
+    QspiLcdDisplay(esp_lcd_panel_io_handle_t panel_io, esp_lcd_panel_handle_t panel,
+                   int width, int height, int offset_x, int offset_y,
+                   bool mirror_x, bool mirror_y, bool swap_xy,
+                   DisplayFonts fonts);
+};
+
+// MCU8080 LCD显示器
+class Mcu8080LcdDisplay : public LcdDisplay {
+public:
+    Mcu8080LcdDisplay(esp_lcd_panel_io_handle_t panel_io, esp_lcd_panel_handle_t panel,
+                      int width, int height, int offset_x, int offset_y,
+                      bool mirror_x, bool mirror_y, bool swap_xy,
+                      DisplayFonts fonts);
+};
+#endif // LCD_DISPLAY_H

main/display/oled_display.cc

@@ -0,0 +1,310 @@
+#include "oled_display.h"
+#include "assets/lang_config.h"
+
+#include <string>
+#include <algorithm>
+
+#include <esp_log.h>
+#include <esp_err.h>
+#include <esp_lvgl_port.h>
+#include <font_awesome.h>
+
+#define TAG "OledDisplay"
+
+LV_FONT_DECLARE(font_awesome_30_1);
+
+OledDisplay::OledDisplay(esp_lcd_panel_io_handle_t panel_io, esp_lcd_panel_handle_t panel,
+    int width, int height, bool mirror_x, bool mirror_y, DisplayFonts fonts)
+    : panel_io_(panel_io), panel_(panel), fonts_(fonts) {
+    width_ = width;
+    height_ = height;
+
+    ESP_LOGI(TAG, "Initialize LVGL");
+    lvgl_port_cfg_t port_cfg = ESP_LVGL_PORT_INIT_CONFIG();
+    port_cfg.task_priority = 1;
+    port_cfg.task_stack = 6144;
+    port_cfg.timer_period_ms = 40;
+    lvgl_port_init(&port_cfg);
+
+    ESP_LOGI(TAG, "Adding OLED display");
+    const lvgl_port_display_cfg_t display_cfg = {
+        .io_handle = panel_io_,
+        .panel_handle = panel_,
+        .control_handle = nullptr,
+        .buffer_size = static_cast<uint32_t>(width_ * height_),
+        .double_buffer = false,
+        .trans_size = 0,
+        .hres = static_cast<uint32_t>(width_),
+        .vres = static_cast<uint32_t>(height_),
+        .monochrome = true,
+        .rotation = {
+            .swap_xy = false,
+            .mirror_x = mirror_x,
+            .mirror_y = mirror_y,
+        },
+        .flags = {
+            .buff_dma = 1,
+            .buff_spiram = 0,
+            .sw_rotate = 0,
+            .full_refresh = 0,
+            .direct_mode = 0,
+        },
+    };
+
+    display_ = lvgl_port_add_disp(&display_cfg);
+    if (display_ == nullptr) {
+        ESP_LOGE(TAG, "Failed to add display");
+        return;
+    }
+
+    if (height_ == 64) {
+        SetupUI_128x64();
+    } else {
+        SetupUI_128x32();
+    }
+}
+
+OledDisplay::~OledDisplay() {
+    if (content_ != nullptr) {
+        lv_obj_del(content_);
+    }
+    if (status_bar_ != nullptr) {
+        lv_obj_del(status_bar_);
+    }
+    if (side_bar_ != nullptr) {
+        lv_obj_del(side_bar_);
+    }
+    if (container_ != nullptr) {
+        lv_obj_del(container_);
+    }
+
+    if (panel_ != nullptr) {
+        esp_lcd_panel_del(panel_);
+    }
+    if (panel_io_ != nullptr) {
+        esp_lcd_panel_io_del(panel_io_);
+    }
+    lvgl_port_deinit();
+}
+
+bool OledDisplay::Lock(int timeout_ms) {
+    return lvgl_port_lock(timeout_ms);
+}
+
+void OledDisplay::Unlock() {
+    lvgl_port_unlock();
+}
+
+void OledDisplay::SetChatMessage(const char* role, const char* content) {
+    DisplayLockGuard lock(this);
+    if (chat_message_label_ == nullptr) {
+        return;
+    }
+
+    // Replace all newlines with spaces
+    std::string content_str = content;
+    std::replace(content_str.begin(), content_str.end(), '\n', ' ');
+
+    if (content_right_ == nullptr) {
+        lv_label_set_text(chat_message_label_, content_str.c_str());
+    } else {
+        if (content == nullptr || content[0] == '\0') {
+            lv_obj_add_flag(content_right_, LV_OBJ_FLAG_HIDDEN);
+        } else {
+            lv_label_set_text(chat_message_label_, content_str.c_str());
+            lv_obj_remove_flag(content_right_, LV_OBJ_FLAG_HIDDEN);
+        }
+    }
+}
+
+void OledDisplay::SetupUI_128x64() {
+    DisplayLockGuard lock(this);
+
+    auto screen = lv_screen_active();
+    lv_obj_set_style_text_font(screen, fonts_.text_font, 0);
+    lv_obj_set_style_text_color(screen, lv_color_black(), 0);
+
+    /* Container */
+    container_ = lv_obj_create(screen);
+    lv_obj_set_size(container_, LV_HOR_RES, LV_VER_RES);
+    lv_obj_set_flex_flow(container_, LV_FLEX_FLOW_COLUMN);
+    lv_obj_set_style_pad_all(container_, 0, 0);
+    lv_obj_set_style_border_width(container_, 0, 0);
+    lv_obj_set_style_pad_row(container_, 0, 0);
+
+    /* Status bar */
+    status_bar_ = lv_obj_create(container_);
+    lv_obj_set_size(status_bar_, LV_HOR_RES, 16);
+    lv_obj_set_style_border_width(status_bar_, 0, 0);
+    lv_obj_set_style_pad_all(status_bar_, 0, 0);
+    lv_obj_set_style_radius(status_bar_, 0, 0);
+
+    /* Content */
+    content_ = lv_obj_create(container_);
+    lv_obj_set_scrollbar_mode(content_, LV_SCROLLBAR_MODE_OFF);
+    lv_obj_set_style_radius(content_, 0, 0);
+    lv_obj_set_style_pad_all(content_, 0, 0);
+    lv_obj_set_width(content_, LV_HOR_RES);
+    lv_obj_set_flex_grow(content_, 1);
+    lv_obj_set_flex_flow(content_, LV_FLEX_FLOW_ROW);
+    lv_obj_set_style_flex_main_place(content_, LV_FLEX_ALIGN_CENTER, 0);
+
+    // 创建左侧固定宽度的容器
+    content_left_ = lv_obj_create(content_);
+    lv_obj_set_size(content_left_, 32, LV_SIZE_CONTENT);  // 固定宽度32像素
+    lv_obj_set_style_pad_all(content_left_, 0, 0);
+    lv_obj_set_style_border_width(content_left_, 0, 0);
+
+    emotion_label_ = lv_label_create(content_left_);
+    lv_obj_set_style_text_font(emotion_label_, &font_awesome_30_1, 0);
+    lv_label_set_text(emotion_label_, FONT_AWESOME_MICROCHIP_AI);
+    lv_obj_center(emotion_label_);
+    lv_obj_set_style_pad_top(emotion_label_, 8, 0);
+
+    // 创建右侧可扩展的容器
+    content_right_ = lv_obj_create(content_);
+    lv_obj_set_size(content_right_, LV_SIZE_CONTENT, LV_SIZE_CONTENT);
+    lv_obj_set_style_pad_all(content_right_, 0, 0);
+    lv_obj_set_style_border_width(content_right_, 0, 0);
+    lv_obj_set_flex_grow(content_right_, 1);
+    lv_obj_add_flag(content_right_, LV_OBJ_FLAG_HIDDEN);
+
+    chat_message_label_ = lv_label_create(content_right_);
+    lv_label_set_text(chat_message_label_, "");
+    lv_label_set_long_mode(chat_message_label_, LV_LABEL_LONG_SCROLL_CIRCULAR);
+    lv_obj_set_style_text_align(chat_message_label_, LV_TEXT_ALIGN_LEFT, 0);
+    lv_obj_set_width(chat_message_label_, width_ - 32);
+    lv_obj_set_style_pad_top(chat_message_label_, 14, 0);
+
+    // 延迟一定的时间后开始滚动字幕
+    static lv_anim_t a;
+    lv_anim_init(&a);
+    lv_anim_set_delay(&a, 1000);
+    lv_anim_set_repeat_count(&a, LV_ANIM_REPEAT_INFINITE);
+    lv_obj_set_style_anim(chat_message_label_, &a, LV_PART_MAIN);
+    lv_obj_set_style_anim_duration(chat_message_label_, lv_anim_speed_clamped(60, 300, 60000), LV_PART_MAIN);
+
+    /* Status bar */
+    lv_obj_set_flex_flow(status_bar_, LV_FLEX_FLOW_ROW);
+    lv_obj_set_style_pad_all(status_bar_, 0, 0);
+    lv_obj_set_style_border_width(status_bar_, 0, 0);
+    lv_obj_set_style_pad_column(status_bar_, 0, 0);
+
+    network_label_ = lv_label_create(status_bar_);
+    lv_label_set_text(network_label_, "");
+    lv_obj_set_style_text_font(network_label_, fonts_.icon_font, 0);
+
+    notification_label_ = lv_label_create(status_bar_);
+    lv_obj_set_flex_grow(notification_label_, 1);
+    lv_obj_set_style_text_align(notification_label_, LV_TEXT_ALIGN_CENTER, 0);
+    lv_label_set_text(notification_label_, "");
+    lv_obj_add_flag(notification_label_, LV_OBJ_FLAG_HIDDEN);
+
+    status_label_ = lv_label_create(status_bar_);
+    lv_obj_set_flex_grow(status_label_, 1);
+    lv_label_set_text(status_label_, Lang::Strings::INITIALIZING);
+    lv_obj_set_style_text_align(status_label_, LV_TEXT_ALIGN_CENTER, 0);
+
+    mute_label_ = lv_label_create(status_bar_);
+    lv_label_set_text(mute_label_, "");
+    lv_obj_set_style_text_font(mute_label_, fonts_.icon_font, 0);
+
+    battery_label_ = lv_label_create(status_bar_);
+    lv_label_set_text(battery_label_, "");
+    lv_obj_set_style_text_font(battery_label_, fonts_.icon_font, 0);
+
+    low_battery_popup_ = lv_obj_create(screen);
+    lv_obj_set_scrollbar_mode(low_battery_popup_, LV_SCROLLBAR_MODE_OFF);
+    lv_obj_set_size(low_battery_popup_, LV_HOR_RES * 0.9, fonts_.text_font->line_height * 2);
+    lv_obj_align(low_battery_popup_, LV_ALIGN_BOTTOM_MID, 0, 0);
+    lv_obj_set_style_bg_color(low_battery_popup_, lv_color_black(), 0);
+    lv_obj_set_style_radius(low_battery_popup_, 10, 0);
+    low_battery_label_ = lv_label_create(low_battery_popup_);
+    lv_label_set_text(low_battery_label_, Lang::Strings::BATTERY_NEED_CHARGE);
+    lv_obj_set_style_text_color(low_battery_label_, lv_color_white(), 0);
+    lv_obj_center(low_battery_label_);
+    lv_obj_add_flag(low_battery_popup_, LV_OBJ_FLAG_HIDDEN);
+}
+
+void OledDisplay::SetupUI_128x32() {
+    DisplayLockGuard lock(this);
+
+    auto screen = lv_screen_active();
+    lv_obj_set_style_text_font(screen, fonts_.text_font, 0);
+
+    /* Container */
+    container_ = lv_obj_create(screen);
+    lv_obj_set_size(container_, LV_HOR_RES, LV_VER_RES);
+    lv_obj_set_flex_flow(container_, LV_FLEX_FLOW_ROW);
+    lv_obj_set_style_pad_all(container_, 0, 0);
+    lv_obj_set_style_border_width(container_, 0, 0);
+    lv_obj_set_style_pad_column(container_, 0, 0);
+
+    /* Emotion label on the left side */
+    content_ = lv_obj_create(container_);
+    lv_obj_set_size(content_, 32, 32);
+    lv_obj_set_style_pad_all(content_, 0, 0);
+    lv_obj_set_style_border_width(content_, 0, 0);
+    lv_obj_set_style_radius(content_, 0, 0);
+
+    emotion_label_ = lv_label_create(content_);
+    lv_obj_set_style_text_font(emotion_label_, &font_awesome_30_1, 0);
+    lv_label_set_text(emotion_label_, FONT_AWESOME_MICROCHIP_AI);
+    lv_obj_center(emotion_label_);
+
+    /* Right side */
+    side_bar_ = lv_obj_create(container_);
+    lv_obj_set_size(side_bar_, width_ - 32, 32);
+    lv_obj_set_flex_flow(side_bar_, LV_FLEX_FLOW_COLUMN);
+    lv_obj_set_style_pad_all(side_bar_, 0, 0);
+    lv_obj_set_style_border_width(side_bar_, 0, 0);
+    lv_obj_set_style_radius(side_bar_, 0, 0);
+    lv_obj_set_style_pad_row(side_bar_, 0, 0);
+
+    /* Status bar */
+    status_bar_ = lv_obj_create(side_bar_);
+    lv_obj_set_size(status_bar_, width_ - 32, 16);
+    lv_obj_set_style_radius(status_bar_, 0, 0);
+    lv_obj_set_flex_flow(status_bar_, LV_FLEX_FLOW_ROW);
+    lv_obj_set_style_pad_all(status_bar_, 0, 0);
+    lv_obj_set_style_border_width(status_bar_, 0, 0);
+    lv_obj_set_style_pad_column(status_bar_, 0, 0);
+
+    status_label_ = lv_label_create(status_bar_);
+    lv_obj_set_flex_grow(status_label_, 1);
+    lv_obj_set_style_pad_left(status_label_, 2, 0);
+    lv_label_set_text(status_label_, Lang::Strings::INITIALIZING);
+
+    notification_label_ = lv_label_create(status_bar_);
+    lv_obj_set_flex_grow(notification_label_, 1);
+    lv_obj_set_style_pad_left(notification_label_, 2, 0);
+    lv_label_set_text(notification_label_, "");
+    lv_obj_add_flag(notification_label_, LV_OBJ_FLAG_HIDDEN);
+
+    mute_label_ = lv_label_create(status_bar_);
+    lv_label_set_text(mute_label_, "");
+    lv_obj_set_style_text_font(mute_label_, fonts_.icon_font, 0);
+
+    network_label_ = lv_label_create(status_bar_);
+    lv_label_set_text(network_label_, "");
+    lv_obj_set_style_text_font(network_label_, fonts_.icon_font, 0);
+
+    battery_label_ = lv_label_create(status_bar_);
+    lv_label_set_text(battery_label_, "");
+    lv_obj_set_style_text_font(battery_label_, fonts_.icon_font, 0);
+
+    chat_message_label_ = lv_label_create(side_bar_);
+    lv_obj_set_size(chat_message_label_, width_ - 32, LV_SIZE_CONTENT);
+    lv_obj_set_style_pad_left(chat_message_label_, 2, 0);
+    lv_label_set_long_mode(chat_message_label_, LV_LABEL_LONG_SCROLL_CIRCULAR);
+    lv_label_set_text(chat_message_label_, "");
+
+    // 延迟一定的时间后开始滚动字幕
+    static lv_anim_t a;
+    lv_anim_init(&a);
+    lv_anim_set_delay(&a, 1000);
+    lv_anim_set_repeat_count(&a, LV_ANIM_REPEAT_INFINITE);
+    lv_obj_set_style_anim(chat_message_label_, &a, LV_PART_MAIN);
+    lv_obj_set_style_anim_duration(chat_message_label_, lv_anim_speed_clamped(60, 300, 60000), LV_PART_MAIN);
+}
+

main/display/oled_display.h

@@ -0,0 +1,37 @@
+#ifndef OLED_DISPLAY_H
+#define OLED_DISPLAY_H
+
+#include "display.h"
+
+#include <esp_lcd_panel_io.h>
+#include <esp_lcd_panel_ops.h>
+
+class OledDisplay : public Display {
+private:
+    esp_lcd_panel_io_handle_t panel_io_ = nullptr;
+    esp_lcd_panel_handle_t panel_ = nullptr;
+
+    lv_obj_t* status_bar_ = nullptr;
+    lv_obj_t* content_ = nullptr;
+    lv_obj_t* content_left_ = nullptr;
+    lv_obj_t* content_right_ = nullptr;
+    lv_obj_t* container_ = nullptr;
+    lv_obj_t* side_bar_ = nullptr;
+
+    DisplayFonts fonts_;
+
+    virtual bool Lock(int timeout_ms = 0) override;
+    virtual void Unlock() override;
+
+    void SetupUI_128x64();
+    void SetupUI_128x32();
+
+public:
+    OledDisplay(esp_lcd_panel_io_handle_t panel_io, esp_lcd_panel_handle_t panel, int width, int height, bool mirror_x, bool mirror_y,
+                DisplayFonts fonts);
+    ~OledDisplay();
+
+    virtual void SetChatMessage(const char* role, const char* content) override;
+};
+
+#endif // OLED_DISPLAY_H