Ink-Board/ink-board
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Enhance timestamp parsing and arrival data handling in MainUIHandler

Browse Source 
- Introduced a new helper function to parse ISO 8601-like timestamps into epoch seconds.
- Improved the handling of timezones, allowing for better accuracy in arrival time calculations.
- Refactored arrival data fetching to ensure UI updates only when data changes.
- Enhanced error handling for arrival data retrieval, providing clearer messages for various error states.
- Updated formatting functions for arrival times to handle both relative and absolute formats more robustly.
This commit is contained in:
GW_MC
2026-02-04 11:54:37 +08:00
parent af0da04e7d
commit 05a65988dd
2 changed files with 686 additions and 552 deletions
Download Patch File Download Diff File Expand all files Collapse all files

559
main/ui/apps/travel/ui/main.cpp
View File

@@ -4,317 +4,318 @@
#include "esp_log.h" #include "esp_log.h"
static const char* TAG = "TravelMainUI"; static const char* TAG = "TravelMainUI";
#define LVGL_PORT_LOCK_TIMEOUT_MS 6000
namespace travel { namespace travel {
MainUI::MainUI() = default; MainUI::MainUI() = default;
MainUI::~MainUI() { MainUI::~MainUI() {
deinit(); deinit();
}
esp_err_t MainUI::init(lv_obj_t* parent) {
if (!parent) {
ESP_LOGE(TAG, "Parent is null");
return ESP_ERR_INVALID_ARG;
} }
parent_ = parent; esp_err_t MainUI::init(lv_obj_t* parent) {
if (!parent) {
if (!lvgl_port_lock(pdMS_TO_TICKS(1000))) { ESP_LOGE(TAG, "Parent is null");
ESP_LOGE(TAG, "Failed to acquire LVGL lock"); return ESP_ERR_INVALID_ARG;
return ESP_ERR_TIMEOUT;
}
// Create main container
container_ = lv_obj_create(parent_);
lv_obj_set_size(container_, LV_PCT(100), LV_PCT(100));
lv_obj_set_flex_flow(container_, LV_FLEX_FLOW_COLUMN);
lv_obj_set_flex_align(container_, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_START);
lv_obj_set_style_pad_all(container_, 5, 0);
lv_obj_set_style_bg_opa(container_, LV_OPA_TRANSP, 0);
lv_obj_set_style_border_width(container_, 0, 0);
// Disable animations and scrolling for e-ink
lv_obj_set_style_anim_time(container_, 0, 0);
lv_obj_clear_flag(container_, LV_OBJ_FLAG_SCROLLABLE);
create_header_();
create_route_displays_();
// Message label for errors/empty state
msg_label_ = lv_label_create(container_);
lv_obj_set_width(msg_label_, LV_PCT(100));
lv_label_set_text(msg_label_, "");
lv_obj_set_style_text_font(msg_label_, &noto_sans_tc_14, 0);
lv_obj_add_flag(msg_label_, LV_OBJ_FLAG_HIDDEN);
// Refresh time label at bottom
refresh_time_label_ = lv_label_create(container_);
lv_obj_set_width(refresh_time_label_, LV_PCT(100));
lv_label_set_text(refresh_time_label_, "");
lv_obj_set_style_text_font(refresh_time_label_, &noto_sans_tc_14, 0);
lv_obj_set_style_text_color(refresh_time_label_, lv_color_hex(0x808080), 0);
lvgl_port_unlock();
return ESP_OK;
}
esp_err_t MainUI::deinit() {
if (!lvgl_port_lock(pdMS_TO_TICKS(1000))) {
ESP_LOGE(TAG, "Failed to acquire LVGL lock");
return ESP_ERR_TIMEOUT;
}
if (container_) {
lv_obj_del(container_);
container_ = nullptr;
}
// Reset all pointers
header_label_ = nullptr;
settings_btn_ = nullptr;
refresh_time_label_ = nullptr;
msg_label_ = nullptr;
for (auto& display : route_displays_) {
display.container = nullptr;
display.header = nullptr;
for (int i = 0; i < MAX_ARRIVALS_PER_ROUTE; i++) {
display.arrival_labels[i] = nullptr;
} }
}
lvgl_port_unlock(); parent_ = parent;
parent_ = nullptr;
return ESP_OK; if (!lvgl_port_lock(pdMS_TO_TICKS(LVGL_PORT_LOCK_TIMEOUT_MS))) {
} ESP_LOGE(TAG, "Failed to acquire LVGL lock");
return ESP_ERR_TIMEOUT;
void MainUI::create_header_() {
// Header container
lv_obj_t* header = lv_obj_create(container_);
lv_obj_set_size(header, LV_PCT(100), 35);
lv_obj_set_flex_flow(header, LV_FLEX_FLOW_ROW);
lv_obj_set_flex_align(header, LV_FLEX_ALIGN_SPACE_BETWEEN, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER);
lv_obj_set_style_pad_hor(header, 5, 0);
lv_obj_set_style_bg_opa(header, LV_OPA_TRANSP, 0);
lv_obj_set_style_border_width(header, 0, 0);
lv_obj_set_style_border_width(header, 1, 0);
lv_obj_set_style_border_side(header, LV_BORDER_SIDE_BOTTOM, 0);
lv_obj_set_style_border_color(header, lv_color_hex(0x808080), 0);
lv_obj_set_style_anim_time(header, 0, 0);
lv_obj_clear_flag(header, LV_OBJ_FLAG_SCROLLABLE);
// Title label
header_label_ = lv_label_create(header);
lv_label_set_text(header_label_, "MTR到站時間");
lv_obj_set_style_text_font(header_label_, &noto_sans_tc_14, 0);
// Settings button
settings_btn_ = lv_btn_create(header);
lv_obj_set_size(settings_btn_, 30, 30);
lv_obj_t* btn_label = lv_label_create(settings_btn_);
lv_label_set_text(btn_label, LV_SYMBOL_SETTINGS);
lv_obj_center(btn_label);
lv_obj_set_style_anim_time(settings_btn_, 0, 0);
}
void MainUI::create_route_displays_() {
for (int i = 0; i < MAX_DISPLAY_ROUTES; i++) {
RouteDisplay& display = route_displays_[i];
// Container for each route
display.container = lv_obj_create(container_);
lv_obj_set_size(display.container, LV_PCT(100), LV_SIZE_CONTENT);
lv_obj_set_flex_flow(display.container, LV_FLEX_FLOW_COLUMN);
lv_obj_set_style_pad_all(display.container, 3, 0);
lv_obj_set_style_bg_opa(display.container, LV_OPA_TRANSP, 0);
lv_obj_set_style_border_width(display.container, 0, 0);
lv_obj_set_style_border_width(display.container, 1, 0);
lv_obj_set_style_border_side(display.container, LV_BORDER_SIDE_BOTTOM, 0);
lv_obj_set_style_border_color(display.container, lv_color_hex(0xC0C0C0), 0);
lv_obj_set_style_anim_time(display.container, 0, 0);
lv_obj_clear_flag(display.container, LV_OBJ_FLAG_SCROLLABLE);
lv_obj_add_flag(display.container, LV_OBJ_FLAG_HIDDEN); // Hidden by default
// Route header (station -> destination with line color)
display.header = lv_label_create(display.container);
lv_obj_set_width(display.header, LV_PCT(100));
lv_label_set_text(display.header, "");
lv_obj_set_style_text_font(display.header, &noto_sans_tc_14, 0);
// Arrival labels (up to 3 per route)
for (int j = 0; j < MAX_ARRIVALS_PER_ROUTE; j++) {
display.arrival_labels[j] = lv_label_create(display.container);
lv_obj_set_width(display.arrival_labels[j], LV_PCT(100));
lv_label_set_text(display.arrival_labels[j], "");
lv_obj_set_style_text_font(display.arrival_labels[j], &noto_sans_tc_14, 0);
lv_obj_set_style_pad_left(display.arrival_labels[j], 10, 0);
} }
}
}
void MainUI::update_arrivals(const std::vector<RouteArrivalData>& arrival_data) { // Create main container
if (!lvgl_port_lock(pdMS_TO_TICKS(1000))) { container_ = lv_obj_create(parent_);
ESP_LOGE(TAG, "Failed to acquire LVGL lock"); lv_obj_set_size(container_, LV_PCT(100), LV_PCT(100));
return; lv_obj_set_flex_flow(container_, LV_FLEX_FLOW_COLUMN);
} lv_obj_set_flex_align(container_, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_START);
lv_obj_set_style_pad_all(container_, 5, 0);
lv_obj_set_style_bg_opa(container_, LV_OPA_TRANSP, 0);
lv_obj_set_style_border_width(container_, 0, 0);
// Disable animations and scrolling for e-ink
lv_obj_set_style_anim_time(container_, 0, 0);
lv_obj_clear_flag(container_, LV_OBJ_FLAG_SCROLLABLE);
// Hide message label only if it's currently visible create_header_();
if (!lv_obj_has_flag(msg_label_, LV_OBJ_FLAG_HIDDEN)) { create_route_displays_();
// Message label for errors/empty state
msg_label_ = lv_label_create(container_);
lv_obj_set_width(msg_label_, LV_PCT(100));
lv_label_set_text(msg_label_, "");
lv_obj_set_style_text_font(msg_label_, &noto_sans_tc_14, 0);
lv_obj_add_flag(msg_label_, LV_OBJ_FLAG_HIDDEN); lv_obj_add_flag(msg_label_, LV_OBJ_FLAG_HIDDEN);
// Refresh time label at bottom
refresh_time_label_ = lv_label_create(container_);
lv_obj_set_width(refresh_time_label_, LV_PCT(100));
lv_label_set_text(refresh_time_label_, "");
lv_obj_set_style_text_font(refresh_time_label_, &noto_sans_tc_14, 0);
lv_obj_set_style_text_color(refresh_time_label_, lv_color_black(), 0);
lvgl_port_unlock();
return ESP_OK;
} }
// Update each route display esp_err_t MainUI::deinit() {
for (int i = 0; i < MAX_DISPLAY_ROUTES; i++) { if (!lvgl_port_lock(pdMS_TO_TICKS(LVGL_PORT_LOCK_TIMEOUT_MS))) {
if (i < static_cast<int>(arrival_data.size())) { ESP_LOGE(TAG, "Failed to acquire LVGL lock");
update_route_display_(route_displays_[i], arrival_data[i]); return ESP_ERR_TIMEOUT;
} else { }
// Hide unused route displays if currently visible
if (route_displays_[i].cached_visible) { if (container_) {
lv_obj_add_flag(route_displays_[i].container, LV_OBJ_FLAG_HIDDEN); lv_obj_del(container_);
route_displays_[i].cached_visible = false; container_ = nullptr;
}
// Reset all pointers
header_label_ = nullptr;
settings_btn_ = nullptr;
refresh_time_label_ = nullptr;
msg_label_ = nullptr;
for (auto& display : route_displays_) {
display.container = nullptr;
display.header = nullptr;
for (int i = 0; i < MAX_ARRIVALS_PER_ROUTE; i++) {
display.arrival_labels[i] = nullptr;
}
}
lvgl_port_unlock();
parent_ = nullptr;
return ESP_OK;
}
void MainUI::create_header_() {
// Header container
lv_obj_t* header = lv_obj_create(container_);
lv_obj_set_size(header, LV_PCT(100), 35);
lv_obj_set_flex_flow(header, LV_FLEX_FLOW_ROW);
lv_obj_set_flex_align(header, LV_FLEX_ALIGN_SPACE_BETWEEN, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER);
lv_obj_set_style_pad_hor(header, 5, 0);
lv_obj_set_style_bg_opa(header, LV_OPA_TRANSP, 0);
lv_obj_set_style_border_width(header, 0, 0);
lv_obj_set_style_border_width(header, 1, 0);
lv_obj_set_style_border_side(header, LV_BORDER_SIDE_BOTTOM, 0);
lv_obj_set_style_border_color(header, lv_color_black(), 0);
lv_obj_set_style_anim_time(header, 0, 0);
lv_obj_clear_flag(header, LV_OBJ_FLAG_SCROLLABLE);
// Title label
header_label_ = lv_label_create(header);
lv_label_set_text(header_label_, "MTR到站時間");
lv_obj_set_style_text_font(header_label_, &noto_sans_tc_14, 0);
// Settings button
settings_btn_ = lv_btn_create(header);
lv_obj_set_size(settings_btn_, 30, 30);
lv_obj_t* btn_label = lv_label_create(settings_btn_);
lv_label_set_text(btn_label, LV_SYMBOL_SETTINGS);
lv_obj_center(btn_label);
lv_obj_set_style_anim_time(settings_btn_, 0, 0);
}
void MainUI::create_route_displays_() {
for (int i = 0; i < MAX_DISPLAY_ROUTES; i++) {
RouteDisplay& display = route_displays_[i];
// Container for each route
display.container = lv_obj_create(container_);
lv_obj_set_size(display.container, LV_PCT(100), LV_SIZE_CONTENT);
lv_obj_set_flex_flow(display.container, LV_FLEX_FLOW_COLUMN);
lv_obj_set_style_pad_all(display.container, 3, 0);
lv_obj_set_style_bg_opa(display.container, LV_OPA_TRANSP, 0);
lv_obj_set_style_border_width(display.container, 0, 0);
lv_obj_set_style_border_width(display.container, 1, 0);
lv_obj_set_style_border_side(display.container, LV_BORDER_SIDE_BOTTOM, 0);
lv_obj_set_style_border_color(display.container, lv_color_black(), 0);
lv_obj_set_style_anim_time(display.container, 0, 0);
lv_obj_clear_flag(display.container, LV_OBJ_FLAG_SCROLLABLE);
lv_obj_add_flag(display.container, LV_OBJ_FLAG_HIDDEN); // Hidden by default
// Route header (station -> destination with line color)
display.header = lv_label_create(display.container);
lv_obj_set_width(display.header, LV_PCT(100));
lv_label_set_text(display.header, "");
lv_obj_set_style_text_font(display.header, &noto_sans_tc_14, 0);
// Arrival labels (up to 3 per route)
for (int j = 0; j < MAX_ARRIVALS_PER_ROUTE; j++) {
display.arrival_labels[j] = lv_label_create(display.container);
lv_obj_set_width(display.arrival_labels[j], LV_PCT(100));
lv_label_set_text(display.arrival_labels[j], "");
lv_obj_set_style_text_font(display.arrival_labels[j], &noto_sans_tc_14, 0);
lv_obj_set_style_pad_left(display.arrival_labels[j], 10, 0);
} }
} }
} }
lvgl_port_unlock(); void MainUI::update_arrivals(const std::vector<RouteArrivalData>& arrival_data) {
} if (!lvgl_port_lock(pdMS_TO_TICKS(LVGL_PORT_LOCK_TIMEOUT_MS))) {
ESP_LOGE(TAG, "Failed to acquire LVGL lock");
void MainUI::update_route_display_(RouteDisplay& display, const RouteArrivalData& data) { return;
// Show container if hidden
if (!display.cached_visible) {
lv_obj_clear_flag(display.container, LV_OBJ_FLAG_HIDDEN);
display.cached_visible = true;
}
// Update header text (station -> direction)
std::string header_text = data.route.station_name + " -> " + data.route.direction_name;
if (header_text != display.cached_header_text) {
lv_label_set_text(display.header, header_text.c_str());
display.cached_header_text = header_text;
}
// Update line color only if changed
if (data.route.line_color != display.cached_line_color) {
if (!data.route.line_color.empty()) {
lv_color_t line_color = hex_to_lv_color_(data.route.line_color);
lv_obj_set_style_text_color(display.header, line_color, 0);
}
display.cached_line_color = data.route.line_color;
}
// Update arrival labels - only if text changed
for (int i = 0; i < MAX_ARRIVALS_PER_ROUTE; i++) {
std::string arrival_text = "";
bool should_show = (i < static_cast<int>(data.arrivals.size()));
if (should_show) {
const auto& arrival = data.arrivals[i];
arrival_text = " " + arrival.arrival_time;
if (!arrival.arrival_time_full.empty()) {
arrival_text += " (" + arrival.arrival_time_full + ")";
}
arrival_text += " " + arrival.direction;
} }
if (arrival_text != display.cached_arrival_texts[i]) { // Hide message label only if it's currently visible
lv_label_set_text(display.arrival_labels[i], arrival_text.c_str()); if (!lv_obj_has_flag(msg_label_, LV_OBJ_FLAG_HIDDEN)) {
display.cached_arrival_texts[i] = arrival_text; lv_obj_add_flag(msg_label_, LV_OBJ_FLAG_HIDDEN);
} }
// Handle visibility only if changed // Update each route display
if (should_show != display.cached_arrival_visible[i]) { for (int i = 0; i < MAX_DISPLAY_ROUTES; i++) {
if (should_show) { if (i < static_cast<int>(arrival_data.size())) {
lv_obj_clear_flag(display.arrival_labels[i], LV_OBJ_FLAG_HIDDEN); update_route_display_(route_displays_[i], arrival_data[i]);
} else { } else {
lv_obj_add_flag(display.arrival_labels[i], LV_OBJ_FLAG_HIDDEN); // Hide unused route displays if currently visible
if (route_displays_[i].cached_visible) {
lv_obj_add_flag(route_displays_[i].container, LV_OBJ_FLAG_HIDDEN);
route_displays_[i].cached_visible = false;
}
}
}
lvgl_port_unlock();
}
void MainUI::update_route_display_(RouteDisplay& display, const RouteArrivalData& data) {
// Show container if hidden
if (!display.cached_visible) {
lv_obj_clear_flag(display.container, LV_OBJ_FLAG_HIDDEN);
display.cached_visible = true;
}
// Update header text (station -> direction)
std::string header_text = data.route.station_name + " -> " + data.route.direction_name;
if (header_text != display.cached_header_text) {
lv_label_set_text(display.header, header_text.c_str());
display.cached_header_text = header_text;
}
// Update line color only if changed
if (data.route.line_color != display.cached_line_color) {
if (!data.route.line_color.empty()) {
lv_color_t line_color = hex_to_lv_color_(data.route.line_color);
lv_obj_set_style_text_color(display.header, line_color, 0);
}
display.cached_line_color = data.route.line_color;
}
// Update arrival labels - only if text changed
for (int i = 0; i < MAX_ARRIVALS_PER_ROUTE; i++) {
std::string arrival_text = "";
bool should_show = (i < static_cast<int>(data.arrivals.size()));
if (should_show) {
const auto& arrival = data.arrivals[i];
arrival_text = " " + arrival.arrival_time;
if (!arrival.arrival_time_full.empty()) {
arrival_text += " (" + arrival.arrival_time_full + ")";
}
arrival_text += " " + arrival.direction;
}
if (arrival_text != display.cached_arrival_texts[i]) {
lv_label_set_text(display.arrival_labels[i], arrival_text.c_str());
display.cached_arrival_texts[i] = arrival_text;
}
// Handle visibility only if changed
if (should_show != display.cached_arrival_visible[i]) {
if (should_show) {
lv_obj_clear_flag(display.arrival_labels[i], LV_OBJ_FLAG_HIDDEN);
} else {
lv_obj_add_flag(display.arrival_labels[i], LV_OBJ_FLAG_HIDDEN);
}
display.cached_arrival_visible[i] = should_show;
}
}
// Show error if any
if (!data.is_valid && !data.error_message.empty()) {
std::string error_text = " 錯誤: " + data.error_message;
if (error_text != display.cached_arrival_texts[0]) {
lv_label_set_text(display.arrival_labels[0], error_text.c_str());
display.cached_arrival_texts[0] = error_text;
}
if (!display.cached_arrival_visible[0]) {
lv_obj_clear_flag(display.arrival_labels[0], LV_OBJ_FLAG_HIDDEN);
display.cached_arrival_visible[0] = true;
} }
display.cached_arrival_visible[i] = should_show;
} }
} }
// Show error if any void MainUI::update_last_refresh_time(const std::string& time_str) {
if (!data.is_valid && !data.error_message.empty()) { if (!lvgl_port_lock(pdMS_TO_TICKS(LVGL_PORT_LOCK_TIMEOUT_MS))) {
std::string error_text = " 錯誤: " + data.error_message; ESP_LOGE(TAG, "Failed to acquire LVGL lock");
if (error_text != display.cached_arrival_texts[0]) { return;
lv_label_set_text(display.arrival_labels[0], error_text.c_str());
display.cached_arrival_texts[0] = error_text;
} }
if (!display.cached_arrival_visible[0]) {
lv_obj_clear_flag(display.arrival_labels[0], LV_OBJ_FLAG_HIDDEN); std::string full_text = "更新: " + time_str;
display.cached_arrival_visible[0] = true; if (full_text != cached_refresh_time_text) {
lv_label_set_text(refresh_time_label_, full_text.c_str());
cached_refresh_time_text = full_text;
}
lvgl_port_unlock();
}
void MainUI::show_no_routes_message() {
if (!lvgl_port_lock(pdMS_TO_TICKS(LVGL_PORT_LOCK_TIMEOUT_MS))) {
ESP_LOGE(TAG, "Failed to acquire LVGL lock");
return;
}
// Hide all route displays
for (auto& display : route_displays_) {
lv_obj_add_flag(display.container, LV_OBJ_FLAG_HIDDEN);
}
// Show message
lv_label_set_text(msg_label_, "請按右上角設定按鈕添加路線");
lv_obj_clear_flag(msg_label_, LV_OBJ_FLAG_HIDDEN);
lvgl_port_unlock();
}
void MainUI::show_error_message(const std::string& message) {
if (!lvgl_port_lock(pdMS_TO_TICKS(LVGL_PORT_LOCK_TIMEOUT_MS))) {
ESP_LOGE(TAG, "Failed to acquire LVGL lock");
return;
}
// Hide all route displays
for (auto& display : route_displays_) {
lv_obj_add_flag(display.container, LV_OBJ_FLAG_HIDDEN);
}
// Show error message
lv_label_set_text(msg_label_, ("錯誤: " + message).c_str());
lv_obj_clear_flag(msg_label_, LV_OBJ_FLAG_HIDDEN);
lvgl_port_unlock();
}
void MainUI::register_settings_button_callback(lv_event_cb_t cb, void* user_data) {
if (settings_btn_) {
lv_obj_add_event_cb(settings_btn_, cb, LV_EVENT_CLICKED, user_data);
} }
} }
}
void MainUI::update_last_refresh_time(const std::string& time_str) { lv_color_t MainUI::hex_to_lv_color_(const std::string& hex_color) {
if (!lvgl_port_lock(pdMS_TO_TICKS(1000))) { if (hex_color.length() < 7 || hex_color[0] != '#') {
ESP_LOGE(TAG, "Failed to acquire LVGL lock"); return lv_color_black();
return; }
unsigned int r = std::stoi(hex_color.substr(1, 2), nullptr, 16);
unsigned int g = std::stoi(hex_color.substr(3, 2), nullptr, 16);
unsigned int b = std::stoi(hex_color.substr(5, 2), nullptr, 16);
return lv_color_make(r, g, b);
} }
std::string full_text = "更新: " + time_str;
if (full_text != cached_refresh_time_text) {
lv_label_set_text(refresh_time_label_, full_text.c_str());
cached_refresh_time_text = full_text;
}
lvgl_port_unlock();
}
void MainUI::show_no_routes_message() {
if (!lvgl_port_lock(pdMS_TO_TICKS(1000))) {
ESP_LOGE(TAG, "Failed to acquire LVGL lock");
return;
}
// Hide all route displays
for (auto& display : route_displays_) {
lv_obj_add_flag(display.container, LV_OBJ_FLAG_HIDDEN);
}
// Show message
lv_label_set_text(msg_label_, "請按右上角設定按鈕添加路線");
lv_obj_clear_flag(msg_label_, LV_OBJ_FLAG_HIDDEN);
lvgl_port_unlock();
}
void MainUI::show_error_message(const std::string& message) {
if (!lvgl_port_lock(pdMS_TO_TICKS(1000))) {
ESP_LOGE(TAG, "Failed to acquire LVGL lock");
return;
}
// Hide all route displays
for (auto& display : route_displays_) {
lv_obj_add_flag(display.container, LV_OBJ_FLAG_HIDDEN);
}
// Show error message
lv_label_set_text(msg_label_, ("錯誤: " + message).c_str());
lv_obj_clear_flag(msg_label_, LV_OBJ_FLAG_HIDDEN);
lvgl_port_unlock();
}
void MainUI::register_settings_button_callback(lv_event_cb_t cb, void* user_data) {
if (settings_btn_) {
lv_obj_add_event_cb(settings_btn_, cb, LV_EVENT_CLICKED, user_data);
}
}
lv_color_t MainUI::hex_to_lv_color_(const std::string& hex_color) {
if (hex_color.length() < 7 || hex_color[0] != '#') {
return lv_color_black();
}
unsigned int r = std::stoi(hex_color.substr(1, 2), nullptr, 16);
unsigned int g = std::stoi(hex_color.substr(3, 2), nullptr, 16);
unsigned int b = std::stoi(hex_color.substr(5, 2), nullptr, 16);
return lv_color_make(r, g, b);
}
} // namespace travel } // namespace travel

679
main/ui/apps/travel/ui/main_handler.cpp
View File

@@ -5,342 +5,475 @@
#include <ctime> #include <ctime>
#include <iomanip> #include <iomanip>
#include <sstream> #include <sstream>
#include <algorithm>
#include <cctype>
static const char* TAG = "TravelMainHandler"; static const char* TAG = "TravelMainHandler";
namespace travel { namespace travel {
MainUIHandler::MainUIHandler() // Helper functions shared by formatting routines
: main_ui_(std::make_unique<MainUI>()) namespace {
, mtr_handler_(std::make_unique<MTRNextTrainHandler>()) { // Parse an ISO 8601-like timestamp into epoch seconds (UTC).
refresh_mutex_ = xSemaphoreCreateMutex(); // Supports formats like: 2024-01-15T14:30:00+08:00, 2026-02-03 23:08:22, or ...Z
} bool parse_iso_to_epoch(const std::string& s, time_t& out_epoch) {
auto trim_copy = [](const std::string& in) {
size_t a = 0;
size_t b = in.size();
while (a < b && std::isspace((unsigned char)in[a])) ++a;
while (b > a && std::isspace((unsigned char)in[b - 1])) --b;
return in.substr(a, b - a);
};
MainUIHandler::~MainUIHandler() { std::string s_trim = trim_copy(s);
deinit(); // Accept either 'T' or space (also lowercase 't') as date/time separator
if (refresh_mutex_) { size_t t_pos = s_trim.find_first_of("Tt ");
vSemaphoreDelete(refresh_mutex_); if (t_pos == std::string::npos) return false;
}
}
esp_err_t MainUIHandler::init( std::string date = trim_copy(s_trim.substr(0, t_pos));
lv_obj_t* parent, std::string tzpart;
InteractionHandler* interaction_handler, std::string timepart = trim_copy(s_trim.substr(t_pos + 1));
SettingHandler* setting_handler,
NetworkHandler* network_handler
) {
ESP_LOGI(TAG, "Initializing main UI handler");
setting_handler_ = setting_handler; // Extract timezone (Z or +HH:MM or +HHMM or +HH)
network_handler_ = network_handler; size_t zpos = timepart.find_first_of("Zz");
if (zpos != std::string::npos) {
tzpart = "Z";
timepart = trim_copy(timepart.substr(0, zpos));
} else {
// Find first '+' or '-' AFTER the numeric time portion
size_t plus = std::string::npos;
for (size_t i = 0; i < timepart.size(); ++i) {
if (timepart[i] == '+' || timepart[i] == '-') { plus = i; break; }
}
if (plus != std::string::npos) {
tzpart = trim_copy(timepart.substr(plus));
timepart = trim_copy(timepart.substr(0, plus));
}
}
// Initialize UI int year = 0, month = 0, day = 0;
esp_err_t err = main_ui_->init(parent); if (sscanf(date.c_str(), "%d-%d-%d", &year, &month, &day) != 3) {
if (err != ESP_OK) { // Try alternative separators like '/'
ESP_LOGE(TAG, "Failed to init main UI"); if (sscanf(date.c_str(), "%d/%d/%d", &year, &month, &day) != 3) return false;
return err; }
int hour = 0, min = 0, sec = 0;
// Remove fractional seconds if present (e.g., 10:34:52.123)
size_t dot = timepart.find('.');
if (dot != std::string::npos) timepart = timepart.substr(0, dot);
int time_parsed = sscanf(timepart.c_str(), "%d:%d:%d", &hour, &min, &sec);
if (time_parsed < 2) {
// Try hour only or hour:minute
if (sscanf(timepart.c_str(), "%d:%d", &hour, &min) == 2) {
sec = 0;
} else {
return false;
}
}
int parsed_offset_seconds = 0; // seconds east of UTC
bool has_tz = false;
if (!tzpart.empty()) {
has_tz = true;
if (tzpart == "Z" || tzpart == "z") {
parsed_offset_seconds = 0;
} else {
char sign = tzpart[0];
int oh = 0, om = 0;
std::string tznum = tzpart.substr(1);
// Accept +HH:MM, +HHMM, or +HH
if (sscanf(tznum.c_str(), "%d:%d", &oh, &om) == 2) {
parsed_offset_seconds = oh * 3600 + om * 60;
} else if (sscanf(tznum.c_str(), "%d", &oh) == 1) {
// If tz like 0800, interpret as HHMM when length>=3
if (tznum.size() >= 3 && tznum.find(':') == std::string::npos && tznum.size() <= 4) {
if (tznum.size() == 4) {
int hh = 0, mm = 0;
if (sscanf(tznum.c_str(), "%2d%2d", &hh, &mm) == 2) {
oh = hh; om = mm;
}
}
parsed_offset_seconds = oh * 3600 + om * 60;
} else {
parsed_offset_seconds = oh * 3600;
}
}
if (sign == '-') parsed_offset_seconds = -parsed_offset_seconds;
}
}
std::tm tm = {};
tm.tm_year = year - 1900;
tm.tm_mon = month - 1;
tm.tm_mday = day;
tm.tm_hour = hour;
tm.tm_min = min;
tm.tm_sec = sec;
tm.tm_isdst = -1;
time_t now = time(nullptr);
std::tm local_tm = *std::localtime(&now);
std::tm gm_tm = *std::gmtime(&now);
time_t local_epoch = mktime(&local_tm);
time_t gm_epoch = mktime(&gm_tm);
int local_offset = static_cast<int>(difftime(local_epoch, gm_epoch));
time_t epoch_assuming_local = mktime(&tm);
if (epoch_assuming_local == (time_t)-1) return false;
if (!has_tz) {
// No timezone provided: assume local time
out_epoch = epoch_assuming_local;
} else {
// Adjust when parsed time had a specific timezone
out_epoch = epoch_assuming_local + (local_offset - parsed_offset_seconds);
}
return true;
}
std::string format_epoch_HHMM(time_t epoch) {
std::tm at = *std::localtime(&epoch);
char buf[6];
strftime(buf, sizeof(buf), "%H:%M", &at);
return std::string(buf);
}
} }
// Register settings button callback MainUIHandler::MainUIHandler()
main_ui_->register_settings_button_callback(on_settings_button_clicked_static_, this); : main_ui_(std::make_unique<MainUI>())
, mtr_handler_(std::make_unique<MTRNextTrainHandler>()) {
refresh_mutex_ = xSemaphoreCreateMutex();
}
MainUIHandler::~MainUIHandler() {
deinit();
if (refresh_mutex_) {
vSemaphoreDelete(refresh_mutex_);
}
}
esp_err_t MainUIHandler::init(
lv_obj_t* parent,
InteractionHandler* interaction_handler,
SettingHandler* setting_handler,
NetworkHandler* network_handler
) {
ESP_LOGI(TAG, "Initializing main UI handler");
setting_handler_ = setting_handler;
network_handler_ = network_handler;
// Initialize UI
esp_err_t err = main_ui_->init(parent);
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to init main UI");
return err;
}
// Register settings button callback
main_ui_->register_settings_button_callback(on_settings_button_clicked_static_, this);
// Check if configured
if (!setting_handler_->is_configured()) {
main_ui_->show_no_routes_message();
return ESP_OK;
}
// Start polling task
polling_running_ = true;
BaseType_t task_created = xTaskCreate(
polling_task_,
"travel_poll",
8192,
this,
5,
&polling_task_handle_
);
if (task_created != pdPASS) {
ESP_LOGE(TAG, "Failed to create polling task");
polling_running_ = false;
return ESP_ERR_NO_MEM;
}
// Do initial refresh
fetch_and_update_arrivals_();
// Check if configured
if (!setting_handler_->is_configured()) {
main_ui_->show_no_routes_message();
return ESP_OK; return ESP_OK;
} }
// Start polling task esp_err_t MainUIHandler::deinit() {
polling_running_ = true; ESP_LOGI(TAG, "Deinitializing main UI handler");
BaseType_t task_created = xTaskCreate(
polling_task_,
"travel_poll",
8192,
this,
5,
&polling_task_handle_
);
if (task_created != pdPASS) { // Stop polling task
ESP_LOGE(TAG, "Failed to create polling task"); if (polling_task_handle_) {
polling_running_ = false; polling_running_ = false;
return ESP_ERR_NO_MEM; // Wait for task to finish
} vTaskDelay(pdMS_TO_TICKS(100));
polling_task_handle_ = nullptr;
// Do initial refresh
fetch_and_update_arrivals_();
return ESP_OK;
}
esp_err_t MainUIHandler::deinit() {
ESP_LOGI(TAG, "Deinitializing main UI handler");
// Stop polling task
if (polling_task_handle_) {
polling_running_ = false;
// Wait for task to finish
vTaskDelay(pdMS_TO_TICKS(100));
polling_task_handle_ = nullptr;
}
// Deinit UI
if (main_ui_) {
main_ui_->deinit();
}
return ESP_OK;
}
void MainUIHandler::register_on_settings_button_clicked(SettingsButtonCallback cb, void* user_data) {
on_settings_callback_ = cb;
settings_callback_user_data_ = user_data;
}
void MainUIHandler::force_refresh() {
if (xSemaphoreTake(refresh_mutex_, pdMS_TO_TICKS(1000)) == pdTRUE) {
fetch_and_update_arrivals_();
xSemaphoreGive(refresh_mutex_);
}
}
void MainUIHandler::polling_task_(void* param) {
MainUIHandler* handler = static_cast<MainUIHandler*>(param);
while (handler->polling_running_) {
uint32_t interval_ms = handler->setting_handler_->get_polling_interval() * 1000;
if (xSemaphoreTake(handler->refresh_mutex_, pdMS_TO_TICKS(1000)) == pdTRUE) {
handler->fetch_and_update_arrivals_();
xSemaphoreGive(handler->refresh_mutex_);
} }
// Delay until next poll // Deinit UI
vTaskDelay(pdMS_TO_TICKS(interval_ms)); if (main_ui_) {
main_ui_->deinit();
}
return ESP_OK;
} }
vTaskDelete(nullptr); void MainUIHandler::register_on_settings_button_clicked(SettingsButtonCallback cb, void* user_data) {
} on_settings_callback_ = cb;
settings_callback_user_data_ = user_data;
void MainUIHandler::fetch_and_update_arrivals_() {
if (!network_handler_ || !setting_handler_) {
return;
} }
const auto& routes = setting_handler_->get_routes(); void MainUIHandler::force_refresh() {
if (routes.empty()) { if (xSemaphoreTake(refresh_mutex_, pdMS_TO_TICKS(1000)) == pdTRUE) {
main_ui_->show_no_routes_message(); fetch_and_update_arrivals_();
return; xSemaphoreGive(refresh_mutex_);
}
} }
std::vector<RouteArrivalData> arrival_data; void MainUIHandler::polling_task_(void* param) {
MainUIHandler* handler = static_cast<MainUIHandler*>(param);
for (const auto& route : routes) { while (handler->polling_running_) {
RouteArrivalData data; uint32_t interval_ms = handler->setting_handler_->get_polling_interval() * 1000;
data.route = route;
// Fetch arrival info from MTR API if (xSemaphoreTake(handler->refresh_mutex_, pdMS_TO_TICKS(1000)) == pdTRUE) {
std::string line_code = route.line_code; handler->fetch_and_update_arrivals_();
std::string station_code = route.station_code; xSemaphoreGive(handler->refresh_mutex_);
StationArrivalInfo* arrival_info = nullptr; }
MtrArrivalErrorCode error = mtr_handler_->get_next_arrival_info( // Delay until next poll
network_handler_, vTaskDelay(pdMS_TO_TICKS(interval_ms));
line_code, }
station_code,
arrival_info,
Language::TC // Traditional Chinese
);
if (error == MtrArrivalErrorCode::NONE && arrival_info) { vTaskDelete(nullptr);
// Determine which direction (UP or DOWN) to filter based on terminal station }
const auto* up_arrivals = arrival_info->up_arrivals();
const auto* down_arrivals = arrival_info->down_arrivals();
// Get all lines to find station positions void MainUIHandler::fetch_and_update_arrivals_() {
std::vector<LineInfo> lines = mtr_handler_->get_lines(); if (!network_handler_ || !setting_handler_) {
return;
}
// Find current line and determine direction const auto& routes = setting_handler_->get_routes();
bool filter_up = false; if (routes.empty()) {
bool filter_down = false; main_ui_->show_no_routes_message();
return;
}
for (const auto& line : lines) { std::vector<RouteArrivalData> arrival_data;
if (std::string(line.code()) == line_code) {
const auto* stations = line.stations();
if (stations) {
// Find index of current station and terminal station
size_t current_idx = SIZE_MAX;
size_t terminal_idx = SIZE_MAX;
for (size_t i = 0; i < stations->size(); i++) { for (const auto& route : routes) {
if (std::string(stations->at(i).code()) == station_code) { RouteArrivalData data;
current_idx = i; data.route = route;
// Fetch arrival info from MTR API
std::string line_code = route.line_code;
std::string station_code = route.station_code;
StationArrivalInfo* arrival_info = nullptr;
MtrArrivalErrorCode error = mtr_handler_->get_next_arrival_info(
network_handler_,
line_code,
station_code,
arrival_info,
Language::TC // Traditional Chinese
);
if (error == MtrArrivalErrorCode::NONE && arrival_info) {
// Determine which direction (UP or DOWN) to filter based on terminal station
const auto* up_arrivals = arrival_info->up_arrivals();
const auto* down_arrivals = arrival_info->down_arrivals();
// Get all lines to find station positions
std::vector<LineInfo> lines = mtr_handler_->get_lines();
// Find current line and determine direction
bool filter_up = false;
bool filter_down = false;
for (const auto& line : lines) {
if (std::string(line.code()) == line_code) {
const auto* stations = line.stations();
if (stations) {
// Find index of current station and terminal station
size_t current_idx = SIZE_MAX;
size_t terminal_idx = SIZE_MAX;
for (size_t i = 0; i < stations->size(); i++) {
if (std::string(stations->at(i).code()) == station_code) {
current_idx = i;
}
if (std::string(stations->at(i).code()) == route.direction) {
terminal_idx = i;
}
} }
if (std::string(stations->at(i).code()) == route.direction) {
terminal_idx = i; // Determine direction: if terminal is at higher index, it's DOWN
} if (current_idx != SIZE_MAX && terminal_idx != SIZE_MAX) {
} if (terminal_idx > current_idx) {
filter_down = true;
// Determine direction: if terminal is at higher index, it's DOWN } else {
if (current_idx != SIZE_MAX && terminal_idx != SIZE_MAX) { filter_up = true;
if (terminal_idx > current_idx) { }
filter_down = true;
} else {
filter_up = true;
} }
} }
break;
} }
break; }
// Filter arrivals based on direction
auto process_arrivals = [&](const std::vector<ArrivalInfo>* arrivals) {
if (!arrivals) return;
for (const auto& arrival : *arrivals) {
ArrivalDisplay display;
display.arrival_time = format_arrival_time_(arrival.arrival_time());
display.arrival_time_full = format_arrival_time_full_(arrival.arrival_time());
display.direction = route.direction_name;
data.arrivals.push_back(display);
}
};
if (filter_up) {
process_arrivals(up_arrivals);
}
if (filter_down) {
process_arrivals(down_arrivals);
}
data.is_valid = true;
// Clean up
delete arrival_info;
} else {
data.is_valid = false;
switch (error) {
case MtrArrivalErrorCode::LINE_NOT_FOUND:
data.error_message = "路線不存在";
break;
case MtrArrivalErrorCode::STATION_NOT_FOUND:
data.error_message = "車站不存在";
break;
case MtrArrivalErrorCode::NO_ARRIVAL_INFO:
data.error_message = "無到站資料";
break;
default:
data.error_message = "無法連接";
break;
} }
} }
// Filter arrivals based on direction arrival_data.push_back(data);
auto process_arrivals = [&](const std::vector<ArrivalInfo>* arrivals) { }
if (!arrivals) return;
for (const auto& arrival : *arrivals) {
ArrivalDisplay display;
display.arrival_time = format_arrival_time_(arrival.arrival_time());
display.arrival_time_full = format_arrival_time_full_(arrival.arrival_time());
display.direction = route.direction_name;
data.arrivals.push_back(display);
}
};
if (filter_up) { // Update UI only if data changed
process_arrivals(up_arrivals); if (has_arrival_data_changed_(arrival_data)) {
} main_ui_->update_arrivals(arrival_data);
if (filter_down) { cached_arrival_data_ = arrival_data;
process_arrivals(down_arrivals); }
} main_ui_->update_last_refresh_time(get_current_time_string_());
}
data.is_valid = true; std::string MainUIHandler::format_arrival_time_(const std::string& api_time) {
// Keep fallback for numeric minute strings (e.g., "0", "6", "15")
if (!api_time.empty() && std::all_of(api_time.begin(), api_time.end(), [](char c) { return std::isdigit((unsigned char)c); })) {
return api_time + "分鐘";
}
// Clean up time_t arrival_epoch = 0;
delete arrival_info; if (parse_iso_to_epoch(api_time, arrival_epoch)) {
} else { time_t now = time(nullptr);
data.is_valid = false; double diff_seconds = difftime(arrival_epoch, now);
switch (error) { if (diff_seconds < 0) diff_seconds = 0; // already arrived -> show 0
case MtrArrivalErrorCode::LINE_NOT_FOUND: int minutes = static_cast<int>((diff_seconds + 59) / 60); // round up
data.error_message = "路線不存在";
break; if (minutes < 60) {
case MtrArrivalErrorCode::STATION_NOT_FOUND: return std::to_string(minutes) + "分鐘";
data.error_message = "車站不存在";
break;
case MtrArrivalErrorCode::NO_ARRIVAL_INFO:
data.error_message = "無到站資料";
break;
default:
data.error_message = "無法連接";
break;
} }
} }
arrival_data.push_back(data); // Only relative minutes are returned from this function.
ESP_LOGW(TAG, "Unable to parse arrival time for relative format: %s", api_time.c_str());
return std::string();
} }
// Update UI only if data changed std::string MainUIHandler::format_arrival_time_full_(const std::string& api_time) {
if (has_arrival_data_changed_(arrival_data)) { // Returns absolute time for display (e.g., "14:32")
main_ui_->update_arrivals(arrival_data); // Returns empty string for relative times
cached_arrival_data_ = arrival_data; if (api_time.length() <= 2) {
} ESP_LOGW(TAG, "Arrival time appears to be relative, no full time available: %s", api_time.c_str());
main_ui_->update_last_refresh_time(get_current_time_string_()); return "";
}
std::string MainUIHandler::format_arrival_time_(const std::string& api_time) {
// API returns time in format like "2024-01-15T14:30:00+08:00" or "2"
// Check if it's a simple minute count
if (api_time.length() <= 2) {
return api_time + "分鐘";
}
// Try to parse ISO format time
// Extract time part (HH:MM)
size_t t_pos = api_time.find('T');
if (t_pos != std::string::npos && api_time.length() > t_pos + 5) {
std::string time_part = api_time.substr(t_pos + 1, 5);
return time_part;
}
// Try to find HH:MM pattern in the string
for (size_t i = 0; i < api_time.length() - 5; i++) {
if (api_time[i] == ':' && i > 0 && i < api_time.length() - 3) {
std::string candidate = api_time.substr(i - 2, 5);
if (isdigit(candidate[0]) && isdigit(candidate[1]) && candidate[2] == ':' &&
isdigit(candidate[3]) && isdigit(candidate[4])) {
return candidate;
}
} }
time_t arrival_epoch = 0;
if (parse_iso_to_epoch(api_time, arrival_epoch)) {
return format_epoch_HHMM(arrival_epoch);
}
// fallback: extract HH:MM
size_t t_pos = api_time.find('T');
if (t_pos != std::string::npos && api_time.length() > t_pos + 5) {
return api_time.substr(t_pos + 1, 5);
}
ESP_LOGW(TAG, "Unable to parse arrival time for full format: %s", api_time.c_str());
return std::string();
} }
return ""; // Return empty instead of raw input std::string MainUIHandler::get_current_time_string_() {
} time_t now = time(nullptr);
std::tm tm = *std::localtime(&now);
std::string MainUIHandler::format_arrival_time_full_(const std::string& api_time) { char buffer[32];
// Returns absolute time for display (e.g., "14:32") // Return absolute local date and time: YYYY-MM-DD HH:MM
// Returns empty string for relative times strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M", &tm);
if (api_time.length() <= 2) { return std::string(buffer);
return "";
} }
size_t t_pos = api_time.find('T'); bool MainUIHandler::has_arrival_data_changed_(const std::vector<RouteArrivalData>& new_data) {
if (t_pos != std::string::npos && api_time.length() > t_pos + 5) { if (new_data.size() != cached_arrival_data_.size()) {
return api_time.substr(t_pos + 1, 5); return true;
} }
return ""; for (size_t i = 0; i < new_data.size(); i++) {
} const auto& new_route = new_data[i];
const auto& cached_route = cached_arrival_data_[i];
std::string MainUIHandler::get_current_time_string_() { if (new_route.route.station_code != cached_route.route.station_code ||
auto now = std::time(nullptr);
auto tm = *std::localtime(&now);
char buffer[6]; // HH:MM\0
strftime(buffer, sizeof(buffer), "%H:%M", &tm);
return std::string(buffer);
}
bool MainUIHandler::has_arrival_data_changed_(const std::vector<RouteArrivalData>& new_data) {
if (new_data.size() != cached_arrival_data_.size()) {
return true;
}
for (size_t i = 0; i < new_data.size(); i++) {
const auto& new_route = new_data[i];
const auto& cached_route = cached_arrival_data_[i];
if (new_route.route.station_code != cached_route.route.station_code ||
new_route.route.direction != cached_route.route.direction || new_route.route.direction != cached_route.route.direction ||
new_route.is_valid != cached_route.is_valid || new_route.is_valid != cached_route.is_valid ||
new_route.error_message != cached_route.error_message) { new_route.error_message != cached_route.error_message) {
return true;
}
if (new_route.arrivals.size() != cached_route.arrivals.size()) {
return true;
}
for (size_t j = 0; j < new_route.arrivals.size(); j++) {
if (new_route.arrivals[j].arrival_time != cached_route.arrivals[j].arrival_time ||
new_route.arrivals[j].arrival_time_full != cached_route.arrivals[j].arrival_time_full) {
return true; return true;
} }
if (new_route.arrivals.size() != cached_route.arrivals.size()) {
return true;
}
for (size_t j = 0; j < new_route.arrivals.size(); j++) {
if (new_route.arrivals[j].arrival_time != cached_route.arrivals[j].arrival_time ||
new_route.arrivals[j].arrival_time_full != cached_route.arrivals[j].arrival_time_full) {
return true;
}
}
}
return false;
}
void MainUIHandler::on_settings_button_clicked_static_(lv_event_t* e) {
MainUIHandler* handler = static_cast<MainUIHandler*>(lv_event_get_user_data(e));
if (handler) {
handler->on_settings_button_clicked_();
} }
} }
return false; void MainUIHandler::on_settings_button_clicked_() {
} if (on_settings_callback_) {
on_settings_callback_(settings_callback_user_data_);
void MainUIHandler::on_settings_button_clicked_static_(lv_event_t* e) { }
MainUIHandler* handler = static_cast<MainUIHandler*>(lv_event_get_user_data(e));
if (handler) {
handler->on_settings_button_clicked_();
} }
}
void MainUIHandler::on_settings_button_clicked_() {
if (on_settings_callback_) {
on_settings_callback_(settings_callback_user_data_);
}
}
} // namespace travel } // namespace travel