adolforeyna/tactility
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Migrate ES3C35P to latest main firmware

Browse Source
This commit is contained in:
Adolfo Reyna
2026-09-10 13:31:10 -04:00
parent 8556103eb1
commit 310b955652
51 changed files with 6873 additions and 181 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Tactility/Source/Tactility.cpp
+4
View File
@@ -40,6 +40,7 @@
#include <Tactility/file/File.h>
#include <Tactility/hal/SdCard.h>
#include <Tactility/lvgl/KeyboardDeviceListener.h>
#include <Tactility/lvgl/Lvgl.h>
#include <Tactility/lvgl/Statusbar.h>
#include <Tactility/lvgl/TrackballInit.h>
#include <Tactility/lvgl/UsbHidInput.h>
@@ -189,6 +190,7 @@ namespace app {
#ifdef ESP_PLATFORM
namespace apwebserver { extern const ::AppManifest manifest; }
namespace crashdiagnostics { extern const ::AppManifest manifest; }
namespace mcpsettings { extern const ::AppManifest manifest; }
#if CONFIG_TT_TDECK_WORKAROUND == 1
namespace keyboardsettings { extern const ::AppManifest manifest; } // T-Deck only for now
#endif
@@ -252,6 +254,7 @@ static void registerInternalApps() {
#ifdef ESP_PLATFORM
app_manager_add(&app::apwebserver::manifest);
app_manager_add(&app::crashdiagnostics::manifest);
app_manager_add(&app::mcpsettings::manifest);
#if defined(CONFIG_TT_TDECK_WORKAROUND)
app_manager_add(&app::keyboardsettings::manifest);
#endif
@@ -433,6 +436,7 @@ static void onLvglStarted() {
if (auto* display = lv_display_get_default(); display != nullptr) {
auto displaySettings = settings::display::loadOrGetDefault();
lv_display_set_rotation(display, settings::display::toLvglDisplayRotation(displaySettings.orientation));
lvgl::applyFontSize(displaySettings.fontSize);
}
lvgl_unlock();
Tactility/Source/app/apphub/AppHubApp.cpp
+6 -1
View File
@@ -107,6 +107,9 @@ void showNoInternet(Context* ctx) {
}
void showApps(Context* ctx) {
if (ctx->contentWrapper == nullptr) {
return;
}
// Refresh rebuilds the list from scratch (cached copy, then again once the network fetch
// lands), which would otherwise reset the user's scroll position each time.
int32_t scrollY;
@@ -266,7 +269,9 @@ void createWidgets(lv_obj_t* parent, void* userData) {
void destroyWidgets(void* userData) {
auto* ctx = static_cast<Context*>(userData);
ctx->scrollY = lv_obj_get_scroll_y(ctx->contentWrapper);
if (ctx->contentWrapper != nullptr) {
ctx->scrollY = lv_obj_get_scroll_y(ctx->contentWrapper);
}
ctx->contentWrapper = nullptr;
ctx->refreshButton = nullptr;
}
Tactility/Source/app/applist/AppList.cpp
+1 -1
View File
@@ -121,7 +121,7 @@ extern const ::AppManifest manifest = {
.category = APP_CATEGORY_SYSTEM,
.location = { .type = APP_LOCATION_MEMORY, .location = reinterpret_cast<void*>(appMain) },
.flags = APP_MANIFEST_FLAG_HIDDEN,
.stack = { .depth = 2400, .desired_memory_capability = 0 },
.stack = { .depth = 3072, .desired_memory_capability = 0 },
};
} // namespace
Tactility/Source/app/display/Display.cpp
+34 -1
View File
@@ -10,6 +10,7 @@
#ifdef ESP_PLATFORM
#include <Tactility/service/displayidle/DisplayIdleService.h>
#endif
#include <Tactility/lvgl/Lvgl.h>
#include <Tactility/settings/DisplaySettings.h>
#include <app/event.h>
@@ -90,6 +91,21 @@ void onOrientationSet(lv_event_t* event) {
}
}
void onFontSizeChanged(lv_event_t* event) {
auto* ctx = static_cast<Context*>(lv_event_get_user_data(event));
auto* dropdown = static_cast<lv_obj_t*>(lv_event_get_target(event));
uint32_t selected_index = lv_dropdown_get_selected(dropdown);
if (selected_index >= static_cast<uint32_t>(settings::display::FontSize::Count)) {
return;
}
auto selected_size = static_cast<settings::display::FontSize>(selected_index);
if (selected_size != ctx->displaySettings.fontSize) {
ctx->displaySettings.fontSize = selected_size;
ctx->displaySettingsUpdated = true;
lvgl::applyFontSize(selected_size);
}
}
void onTimeoutSwitch(lv_event_t* event) {
auto* ctx = static_cast<Context*>(lv_event_get_user_data(event));
auto* sw = static_cast<lv_obj_t*>(lv_event_get_target(event));
@@ -208,6 +224,23 @@ void createWidgets(lv_obj_t* parent, void* userData) {
// Set the dropdown to match current orientation enum
lv_dropdown_set_selected(orientation_dropdown, static_cast<uint16_t>(ctx->displaySettings.orientation));
// Font size
auto* font_size_wrapper = lv_obj_create(main_wrapper);
lv_obj_set_size(font_size_wrapper, LV_PCT(100), LV_SIZE_CONTENT);
lv_obj_set_style_pad_all(font_size_wrapper, 0, LV_STATE_DEFAULT);
lv_obj_set_style_border_width(font_size_wrapper, 0, LV_STATE_DEFAULT);
auto* font_size_label = lv_label_create(font_size_wrapper);
lv_label_set_text(font_size_label, "Font size");
lv_obj_align(font_size_label, LV_ALIGN_LEFT_MID, 0, 0);
auto* font_size_dropdown = lv_dropdown_create(font_size_wrapper);
lv_dropdown_set_options(font_size_dropdown, "Small\nDefault\nLarge");
lv_obj_align(font_size_dropdown, LV_ALIGN_RIGHT_MID, 0, 0);
lv_obj_add_event_cb(font_size_dropdown, onFontSizeChanged, LV_EVENT_VALUE_CHANGED, ctx);
lv_dropdown_set_selected(font_size_dropdown, static_cast<uint16_t>(ctx->displaySettings.fontSize));
// Screen timeout
// Note: DisplayIdleService doesn't act on these settings for kernel-driver displays yet
// (it only looks up the deprecated tt::hal::display::DisplayDevice), so these currently
@@ -274,7 +307,7 @@ void createWidgets(lv_obj_t* parent, void* userData) {
ctx->screensaverDropdown = lv_dropdown_create(screensaver_wrapper);
// Note: order correlates with settings::display::ScreensaverType enum order
lv_dropdown_set_options(ctx->screensaverDropdown, "None\nBouncing Balls\nMystify\nMatrix Rain\nStackChan");
lv_dropdown_set_options(ctx->screensaverDropdown, "None\nBouncing Balls\nMystify\nMatrix Rain\nStackChan\nMCP Screen");
lv_obj_align(ctx->screensaverDropdown, LV_ALIGN_RIGHT_MID, 0, 0);
lv_obj_add_event_cb(ctx->screensaverDropdown, onScreensaverChanged, LV_EVENT_VALUE_CHANGED, ctx);
lv_dropdown_set_selected(ctx->screensaverDropdown, static_cast<uint16_t>(ctx->displaySettings.screensaverType));
Tactility/Source/app/launcher/Launcher.cpp
+254 -170
View File
@@ -3,12 +3,26 @@
#include <app/manifest.h>
#include <app/scheduler.h>
#include <app/start.h>
#include <Tactility/DeprecatedPaths.h>
#include <Tactility/MountPoints.h>
#include <Tactility/Tactility.h>
#include <Tactility/app/setup/Setup.h>
#include <Tactility/file/File.h>
#include <Tactility/lvgl/Lvgl.h>
#include <Tactility/service/wifi/Wifi.h>
#include <Tactility/settings/BootSettings.h>
#include <Tactility/settings/Time.h>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <string>
#include <lvgl.h>
#include <lvgl/icons/launcher.h>
#include <lvgl/fonts.h>
#include <lvgl/icons/launcher.h>
#include <lvgl/icons/statusbar.h>
#include <lvgl/lvgl.h>
#include <lvgl_window_manager/window_manager.h>
@@ -20,64 +34,29 @@
#include <tactility/log.h>
#include <tactility/memory.h>
#include <Tactility/app/setup/Setup.h>
#include <Tactility/settings/BootSettings.h>
#include <Tactility/Tactility.h>
namespace tt::app::launcher {
constexpr auto* TAG = "Launcher";
constexpr auto* BACKGROUND_ASSET = "color-field.png";
constexpr auto* CUSTOM_BACKGROUND_PATH = "tactility/launcher/background.bin";
constexpr lv_color_t TEXT_COLOR = LV_COLOR_MAKE(0xF8, 0xF5, 0xF2);
constexpr lv_color_t MUTED_TEXT_COLOR = LV_COLOR_MAKE(0xDF, 0xD6, 0xD3);
constexpr lv_color_t ACCENT_COLOR = LV_COLOR_MAKE(0xEC, 0x75, 0x69);
namespace {
uint32_t getButtonPadding(UiDensity density, uint32_t buttonSize) {
if (density == LVGL_UI_DENSITY_COMPACT) {
return 0;
} else {
return buttonSize / 8;
}
}
struct LauncherWidgets {
lv_obj_t* timeLabel = nullptr;
lv_obj_t* dateLabel = nullptr;
lv_obj_t* dataLabel = nullptr;
lv_obj_t* statusLabel = nullptr;
lv_timer_t* updateTimer = nullptr;
};
int32_t computeButtonMargin(int32_t available_span, int32_t total_button_size) {
const int32_t usable = std::max<int32_t>(0, available_span - (3 * total_button_size));
return std::min<int32_t>(usable / 16, total_button_size / 2);
}
void onAppPressed(lv_event_t* e) {
auto* appId = static_cast<const char*>(lv_event_get_user_data(e));
void onAppPressed(lv_event_t* event) {
const auto* app_id = static_cast<const char*>(lv_event_get_user_data(event));
uint32_t instance_id = 0;
app_start(appId, 0, nullptr, &instance_id);
}
lv_obj_t* createAppButton(lv_obj_t* parent, UiDensity uiDensity, const char* imageFile, const char* appId, int32_t itemMargin, bool isLandscape) {
const auto button_size = lvgl_get_launcher_icon_font_height();
const auto button_padding = getButtonPadding(uiDensity, button_size);
auto* apps_button = lv_button_create(parent);
lv_obj_set_style_pad_all(apps_button, static_cast<int32_t>(button_padding), LV_STATE_DEFAULT);
if (isLandscape) {
lv_obj_set_style_margin_hor(apps_button, itemMargin, LV_STATE_DEFAULT);
} else {
lv_obj_set_style_margin_ver(apps_button, itemMargin, LV_STATE_DEFAULT);
}
lv_obj_set_style_shadow_width(apps_button, 0, LV_STATE_DEFAULT);
lv_obj_set_style_bg_opa(apps_button, 0, LV_STATE_DEFAULT);
// create the image first
auto* button_image = lv_image_create(apps_button);
lv_obj_set_style_text_font(button_image, lvgl_get_launcher_icon_font(), LV_STATE_DEFAULT);
lv_image_set_src(button_image, imageFile);
lv_obj_set_style_text_color(button_image, lv_theme_get_color_primary(button_image), LV_STATE_DEFAULT);
lv_obj_set_style_image_recolor(button_image, lv_theme_get_color_primary(parent), LV_STATE_DEFAULT);
lv_obj_set_style_image_recolor_opa(button_image, LV_OPA_COVER, LV_STATE_DEFAULT);
// Ensure it's square (Material Symbols are slightly wider than tall)
lv_obj_set_size(button_image, button_size, button_size);
lv_obj_add_event_cb(apps_button, onAppPressed, LV_EVENT_SHORT_CLICKED, (void*)appId);
return apps_button;
app_start(app_id, 0, nullptr, &instance_id);
}
bool shouldShowPowerButton() {
@@ -85,180 +64,288 @@ bool shouldShowPowerButton() {
device_for_each_of_type(&POWER_SUPPLY_TYPE, &show_power_button, [](Device* device, void* context) {
if (device_is_ready(device) && power_supply_supports_power_off(device)) {
*static_cast<bool*>(context) = true;
return false; // stop iterating
} else {
return true; // continue iterating
return false;
}
return true;
});
return show_power_button;
}
void onButtonsWrapperResized(lv_event_t* e);
int getBatteryPercentage() {
Device* power = nullptr;
device_for_each_of_type(&POWER_SUPPLY_TYPE, &power, [](Device* device, void* context) {
if (device_is_ready(device) && power_supply_supports_property(device, POWER_SUPPLY_PROP_CAPACITY)) {
*static_cast<Device**>(context) = device;
return false;
}
return true;
});
if (power == nullptr) return -1;
// The screen object outlives this window's own widgets (lvgl-window-manager deletes and
// recreates only the topmost window's widget on every app switch, not the screen itself), so
// the LV_EVENT_SIZE_CHANGED callback registered on it must be removed once buttons_wrapper is
// destroyed, to avoid a dangling user-data pointer the next time the display rotates while a
// different window is topmost.
void onButtonsWrapperDeleted(lv_event_t* e) {
auto* buttons_wrapper = lv_event_get_target_obj(e);
auto* screen = lv_obj_get_screen(buttons_wrapper);
lv_obj_remove_event_cb_with_user_data(screen, onButtonsWrapperResized, buttons_wrapper);
PowerSupplyPropertyValue charge_level;
if (power_supply_get_property(power, POWER_SUPPLY_PROP_CAPACITY, &charge_level) != ERROR_NONE) return -1;
return std::clamp(charge_level.int_value, 0, 100);
}
// Re-applies the flex direction and per-button margins when the display orientation changes
// while the launcher is the visible window (these are decided once at createWidgets() based on
// the resolution at that time, so a later rotation needs this to catch up).
void onButtonsWrapperResized(lv_event_t* e) {
auto* buttons_wrapper = static_cast<lv_obj_t*>(lv_event_get_user_data(e));
const auto* display = lv_obj_get_display(buttons_wrapper);
const auto button_size = lvgl_get_launcher_icon_font_height();
const auto button_padding = getButtonPadding(lvgl_get_ui_density(), button_size);
const auto total_button_size = button_size + (button_padding * 2);
const auto horizontal_px = lv_display_get_horizontal_resolution(display);
const auto vertical_px = lv_display_get_vertical_resolution(display);
const bool is_landscape_display = horizontal_px >= vertical_px;
const auto current_flow = lv_obj_get_style_flex_flow(buttons_wrapper, LV_PART_MAIN);
const bool was_landscape = current_flow == LV_FLEX_FLOW_ROW;
if (is_landscape_display == was_landscape) {
return;
}
lv_obj_set_flex_flow(buttons_wrapper, is_landscape_display ? LV_FLEX_FLOW_ROW : LV_FLEX_FLOW_COLUMN);
const int32_t margin = is_landscape_display
? computeButtonMargin(horizontal_px, total_button_size)
: computeButtonMargin(vertical_px, total_button_size);
const uint32_t child_count = lv_obj_get_child_count(buttons_wrapper);
for (uint32_t i = 0; i < child_count; i++) {
auto* button = lv_obj_get_child(buttons_wrapper, i);
lv_obj_set_style_margin_hor(button, is_landscape_display ? margin : 0, LV_STATE_DEFAULT);
lv_obj_set_style_margin_ver(button, is_landscape_display ? 0 : margin, LV_STATE_DEFAULT);
const char* getWifiStatusIcon(service::wifi::RadioState state) {
using enum service::wifi::RadioState;
switch (state) {
case ConnectionActive: return LVGL_ICON_STATUSBAR_SIGNAL_WIFI_4_BAR;
case Off:
case OffPending: return LVGL_ICON_STATUSBAR_SIGNAL_WIFI_OFF;
default: return LVGL_ICON_STATUSBAR_SIGNAL_WIFI_0_BAR;
}
}
void createWidgets(lv_obj_t* parent, void*) {
auto* buttons_wrapper = lv_obj_create(parent);
const char* getBatteryStatusIcon(int percentage) {
if (percentage < 0) return "";
if (percentage >= 95) return LVGL_ICON_STATUSBAR_BATTERY_ANDROID_FRAME_FULL;
if (percentage >= 64) return LVGL_ICON_STATUSBAR_BATTERY_ANDROID_FRAME_5;
if (percentage >= 32) return LVGL_ICON_STATUSBAR_BATTERY_ANDROID_FRAME_3;
return LVGL_ICON_STATUSBAR_BATTERY_ANDROID_FRAME_1;
}
auto ui_density = lvgl_get_ui_density();
const auto button_size = lvgl_get_launcher_icon_font_height();
const auto button_padding = getButtonPadding(ui_density, button_size);
const auto total_button_size = button_size + (button_padding * 2);
lv_obj_t* createAppButton(lv_obj_t* parent, const char* icon, const char* app_id, bool emphasized) {
auto* button = lv_button_create(parent);
lv_obj_set_size(button, 52, 52);
lv_obj_set_style_radius(button, 15, LV_PART_MAIN);
lv_obj_set_style_shadow_width(button, 0, LV_PART_MAIN);
lv_obj_set_style_border_width(button, emphasized ? 2 : 1, LV_PART_MAIN);
lv_obj_set_style_border_color(button, emphasized ? ACCENT_COLOR : lv_color_hex(0x746568), LV_PART_MAIN);
lv_obj_set_style_border_opa(button, emphasized ? LV_OPA_COVER : LV_OPA_60, LV_PART_MAIN);
lv_obj_set_style_bg_color(button, lv_color_hex(0x211B20), LV_PART_MAIN);
lv_obj_set_style_bg_opa(button, emphasized ? LV_OPA_80 : LV_OPA_70, LV_PART_MAIN);
lv_obj_set_style_bg_color(button, lv_color_hex(0x392C32), LV_STATE_PRESSED);
lv_obj_set_style_transform_scale(button, 238, LV_STATE_PRESSED);
lv_obj_set_style_outline_color(button, ACCENT_COLOR, LV_STATE_FOCUSED);
lv_obj_set_style_outline_width(button, 2, LV_STATE_FOCUSED);
lv_obj_set_style_outline_pad(button, 2, LV_STATE_FOCUSED);
lv_obj_align(buttons_wrapper, LV_ALIGN_CENTER, 0, 0);
lv_obj_set_size(buttons_wrapper, LV_SIZE_CONTENT, LV_SIZE_CONTENT);
lv_obj_set_style_border_width(buttons_wrapper, 0, LV_STATE_DEFAULT);
lv_obj_set_flex_grow(buttons_wrapper, 1);
auto* image = lv_image_create(button);
lv_obj_set_size(image, 36, 36);
lv_obj_center(image);
lv_obj_set_style_text_font(image, lvgl_get_launcher_icon_font(), LV_STATE_DEFAULT);
lv_image_set_src(image, icon);
lv_obj_set_style_image_recolor(image, TEXT_COLOR, LV_STATE_DEFAULT);
lv_obj_set_style_image_recolor_opa(image, LV_OPA_COVER, LV_STATE_DEFAULT);
lv_obj_add_event_cb(button, onAppPressed, LV_EVENT_SHORT_CLICKED, const_cast<char*>(app_id));
return button;
}
// Fix for button selection
lv_obj_set_style_pad_all(buttons_wrapper, 6, LV_STATE_DEFAULT);
const auto* display = lv_obj_get_display(parent);
const auto horizontal_px = lv_display_get_horizontal_resolution(display);
const auto vertical_px = lv_display_get_vertical_resolution(display);
const bool is_landscape_display = horizontal_px >= vertical_px;
if (is_landscape_display) {
lv_obj_set_flex_flow(buttons_wrapper, LV_FLEX_FLOW_ROW);
void updateInformation(LauncherWidgets& widgets) {
const std::time_t now = std::time(nullptr);
std::tm local_time {};
localtime_r(&now, &local_time);
char time_buffer[12];
char date_buffer[40];
if (local_time.tm_year >= 125) {
if (settings::isTimeFormat24Hour()) {
std::strftime(time_buffer, sizeof(time_buffer), "%H:%M", &local_time);
} else {
std::strftime(time_buffer, sizeof(time_buffer), "%I:%M", &local_time);
if (time_buffer[0] == '0') std::memmove(time_buffer, time_buffer + 1, std::strlen(time_buffer));
}
std::strftime(date_buffer, sizeof(date_buffer), "%A, %B %e", &local_time);
} else {
lv_obj_set_flex_flow(buttons_wrapper, LV_FLEX_FLOW_COLUMN);
std::strcpy(time_buffer, "--:--");
std::strcpy(date_buffer, "Set date and time");
}
lv_label_set_text(widgets.timeLabel, time_buffer);
lv_label_set_text(widgets.dateLabel, date_buffer);
const auto wifi_state = service::wifi::getRadioState();
std::string sd_card_path;
const bool sd_ready = findFirstMountedSdCardPath(sd_card_path);
const int battery_percentage = getBatteryPercentage();
char data_buffer[80];
if (battery_percentage >= 0) {
std::snprintf(data_buffer, sizeof(data_buffer), "%s • %s • %d%%",
wifi_state == service::wifi::RadioState::ConnectionActive ? "Wi-Fi connected" : "Wi-Fi offline",
sd_ready ? "SD ready" : "No SD", battery_percentage);
} else {
std::snprintf(data_buffer, sizeof(data_buffer), "%s • %s",
wifi_state == service::wifi::RadioState::ConnectionActive ? "Wi-Fi connected" : "Wi-Fi offline",
sd_ready ? "SD ready" : "No SD");
}
lv_label_set_text(widgets.dataLabel, data_buffer);
char status_buffer[24];
std::snprintf(status_buffer, sizeof(status_buffer), "%s%s", getWifiStatusIcon(wifi_state), getBatteryStatusIcon(battery_percentage));
lv_label_set_text(widgets.statusLabel, status_buffer);
}
void onUpdateTimer(lv_timer_t* timer) {
updateInformation(*static_cast<LauncherWidgets*>(lv_timer_get_user_data(timer)));
}
std::string getDefaultBackgroundPath() {
return std::string(file::MOUNT_POINT_SYSTEM) + "/app/Launcher/assets/" + BACKGROUND_ASSET;
}
void createWidgets(lv_obj_t* parent, void* user_data) {
auto& widgets = *static_cast<LauncherWidgets*>(user_data);
lv_obj_set_style_bg_color(parent, lv_color_hex(0x211A20), LV_PART_MAIN);
lv_obj_set_style_bg_opa(parent, LV_OPA_COVER, LV_PART_MAIN);
lv_obj_set_style_pad_all(parent, 0, LV_PART_MAIN);
lv_obj_clear_flag(parent, LV_OBJ_FLAG_SCROLLABLE);
auto* display = lv_obj_get_display(parent);
const auto display_width = lv_display_get_horizontal_resolution(display);
const auto display_height = lv_display_get_vertical_resolution(display);
const bool is_portrait = display_height > display_width;
auto background_path = lvgl::PATH_PREFIX + getDefaultBackgroundPath();
std::string sd_card_path;
if (findFirstMountedSdCardPath(sd_card_path)) {
const auto custom_background_path = file::getChildPath(sd_card_path, CUSTOM_BACKGROUND_PATH);
if (file::isFile(custom_background_path)) {
const auto lvgl_custom_background_path = lvgl::PATH_PREFIX + custom_background_path;
lv_image_header_t header {};
if (lv_image_decoder_get_info(lvgl_custom_background_path.c_str(), &header) == LV_RESULT_OK) {
if (header.w >= display_width && header.h >= display_height) {
background_path = lvgl_custom_background_path;
LOG_I(TAG, "Using SD background %s (%ux%u, format 0x%02x)",
custom_background_path.c_str(), header.w, header.h, header.cf);
} else {
LOG_W(TAG, "Ignoring undersized SD background %s (%ux%u for %dx%d display)",
custom_background_path.c_str(), header.w, header.h, display_width, display_height);
}
} else {
LOG_W(TAG, "Ignoring invalid SD background %s", custom_background_path.c_str());
}
}
}
const int32_t margin = is_landscape_display
? computeButtonMargin(lv_display_get_horizontal_resolution(display), total_button_size)
: computeButtonMargin(lv_display_get_vertical_resolution(display), total_button_size);
auto* background = lv_image_create(parent);
lv_image_set_src(background, background_path.c_str());
lv_obj_align(background, LV_ALIGN_CENTER, 0, 0);
lv_obj_add_flag(background, LV_OBJ_FLAG_IGNORE_LAYOUT);
auto* app_list_button = createAppButton(buttons_wrapper, ui_density, LVGL_ICON_LAUNCHER_APPS, "tactility.applist", margin, is_landscape_display);
createAppButton(buttons_wrapper, ui_density, LVGL_ICON_LAUNCHER_FOLDER, "tactility.files", margin, is_landscape_display);
createAppButton(buttons_wrapper, ui_density, LVGL_ICON_LAUNCHER_SETTINGS, "tactility.settings", margin, is_landscape_display);
widgets.timeLabel = lv_label_create(parent);
lv_label_set_text(widgets.timeLabel, "--:--");
lv_obj_set_style_text_color(widgets.timeLabel, TEXT_COLOR, LV_PART_MAIN);
#if LV_FONT_MONTSERRAT_48
lv_obj_set_style_text_font(widgets.timeLabel, &lv_font_montserrat_48, LV_PART_MAIN);
#else
lv_obj_set_style_text_font(widgets.timeLabel, lvgl_get_text_font(FONT_SIZE_LARGE), LV_PART_MAIN);
#endif
lv_obj_align(widgets.timeLabel, LV_ALIGN_TOP_LEFT, 18, 58);
// The launcher's container is several levels below the screen, and LVGL only sends
// LV_EVENT_SIZE_CHANGED to the screen object itself on a resolution change - so the
// handler is attached there, with buttons_wrapper passed through as user data.
lv_obj_add_event_cb(lv_obj_get_screen(parent), onButtonsWrapperResized, LV_EVENT_SIZE_CHANGED, buttons_wrapper);
lv_obj_add_event_cb(buttons_wrapper, onButtonsWrapperDeleted, LV_EVENT_DELETE, nullptr);
widgets.dateLabel = lv_label_create(parent);
lv_obj_set_style_text_font(widgets.dateLabel, lvgl_get_text_font(FONT_SIZE_LARGE), LV_PART_MAIN);
lv_obj_set_style_text_color(widgets.dateLabel, TEXT_COLOR, LV_PART_MAIN);
lv_obj_align(widgets.dateLabel, LV_ALIGN_TOP_LEFT, 20, 118);
widgets.dataLabel = lv_label_create(parent);
lv_obj_set_width(widgets.dataLabel, is_portrait ? display_width - 40 : 225);
lv_label_set_long_mode(widgets.dataLabel, LV_LABEL_LONG_MODE_WRAP);
lv_obj_set_style_text_font(widgets.dataLabel, lvgl_get_text_font(FONT_SIZE_SMALL), LV_PART_MAIN);
lv_obj_set_style_text_color(widgets.dataLabel, MUTED_TEXT_COLOR, LV_PART_MAIN);
lv_obj_align(widgets.dataLabel, LV_ALIGN_TOP_LEFT, 20, 148);
widgets.statusLabel = lv_label_create(parent);
lv_obj_set_style_text_font(widgets.statusLabel, lvgl_get_statusbar_icon_font(), LV_PART_MAIN);
lv_obj_set_style_text_color(widgets.statusLabel, TEXT_COLOR, LV_PART_MAIN);
lv_obj_align(widgets.statusLabel, LV_ALIGN_TOP_RIGHT, -15, 8);
auto* button_rail = lv_obj_create(parent);
if (is_portrait) {
lv_obj_set_size(button_rail, 184, 60);
lv_obj_align(button_rail, LV_ALIGN_BOTTOM_MID, 0, -7);
lv_obj_set_flex_flow(button_rail, LV_FLEX_FLOW_ROW);
} else {
lv_obj_set_size(button_rail, 60, 184);
lv_obj_align(button_rail, LV_ALIGN_RIGHT_MID, -7, 8);
lv_obj_set_flex_flow(button_rail, LV_FLEX_FLOW_COLUMN);
}
lv_obj_set_flex_align(button_rail, LV_FLEX_ALIGN_SPACE_EVENLY, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER);
lv_obj_set_style_pad_all(button_rail, 0, LV_PART_MAIN);
lv_obj_set_style_border_width(button_rail, 0, LV_PART_MAIN);
lv_obj_set_style_bg_opa(button_rail, LV_OPA_TRANSP, LV_PART_MAIN);
lv_obj_clear_flag(button_rail, LV_OBJ_FLAG_SCROLLABLE);
auto* app_list_button = createAppButton(button_rail, LVGL_ICON_LAUNCHER_APPS, "tactility.applist", true);
createAppButton(button_rail, LVGL_ICON_LAUNCHER_FOLDER, "tactility.files", false);
createAppButton(button_rail, LVGL_ICON_LAUNCHER_SETTINGS, "tactility.settings", false);
// Some devices (e.g. T-Lora Pager) have no other way to power off, so the
// button stays in the launcher; the confirmation flow lives in the PowerOff app.
if (shouldShowPowerButton()) {
auto* power_button = lv_button_create(parent);
lv_obj_set_style_pad_all(power_button, 8, 0);
lv_obj_align(power_button, LV_ALIGN_BOTTOM_MID, 0, -10);
lv_obj_add_event_cb(power_button, onAppPressed, LV_EVENT_SHORT_CLICKED, (void*)"tactility.poweroff");
lv_obj_set_style_shadow_width(power_button, 0, LV_STATE_DEFAULT);
lv_obj_set_style_bg_opa(power_button, 0, LV_PART_MAIN);
lv_obj_set_size(power_button, 36, 36);
lv_obj_align(power_button, LV_ALIGN_BOTTOM_LEFT, 16, -12);
lv_obj_set_style_radius(power_button, LV_RADIUS_CIRCLE, LV_PART_MAIN);
lv_obj_set_style_shadow_width(power_button, 0, LV_PART_MAIN);
lv_obj_set_style_bg_color(power_button, lv_color_hex(0x211B20), LV_PART_MAIN);
lv_obj_set_style_bg_opa(power_button, LV_OPA_70, LV_PART_MAIN);
lv_obj_add_event_cb(power_button, onAppPressed, LV_EVENT_SHORT_CLICKED, const_cast<char*>("tactility.poweroff"));
auto* power_label = lv_label_create(power_button);
lv_label_set_text(power_label, LV_SYMBOL_POWER);
lv_obj_set_style_text_color(power_label, lv_theme_get_color_primary(parent), LV_STATE_DEFAULT);
lv_obj_set_style_text_color(power_label, TEXT_COLOR, LV_PART_MAIN);
lv_obj_center(power_label);
}
// If we don't have a touch device, we assume there's some other kind of input like a keyboard, an encoder or button control
// In that scenario we want to automatically have the app list button selected so the user doesn't have to press the widget selection
// an extra time.
if (!device_has_active_by_type(&POINTER_TYPE)) {
// lv_obj_update_layout(parent); // Resolve flex layout first, so focus/state invalidate against final coords
lv_group_focus_obj(app_list_button);
lv_obj_add_state(app_list_button, LV_STATE_FOCUS_KEY);
}
updateInformation(widgets);
widgets.updateTimer = lv_timer_create(onUpdateTimer, 1000, &widgets);
}
void destroyWidgets(void* user_data) {
auto& widgets = *static_cast<LauncherWidgets*>(user_data);
if (widgets.updateTimer != nullptr) {
lv_timer_delete(widgets.updateTimer);
widgets.updateTimer = nullptr;
}
widgets.timeLabel = nullptr;
widgets.dateLabel = nullptr;
widgets.dataLabel = nullptr;
widgets.statusLabel = nullptr;
}
void runAutoStart() {
settings::BootSettings boot_properties;
AppManifest manifest;
if (
// Auto-start due to built-in requirement
strcmp(CONFIG_TT_AUTO_START_APP_ID, "") != 0 &&
app_manager_find_manifest(CONFIG_TT_AUTO_START_APP_ID, &manifest) == ERROR_NONE
) {
if (strcmp(CONFIG_TT_AUTO_START_APP_ID, "") != 0 &&
app_manager_find_manifest(CONFIG_TT_AUTO_START_APP_ID, &manifest) == ERROR_NONE) {
LOG_I(TAG, "Starting %s", CONFIG_TT_AUTO_START_APP_ID);
uint32_t app_launch_id;
app_start(CONFIG_TT_AUTO_START_APP_ID, 0, nullptr, &app_launch_id);
} else if (
// Auto-start due to user configuration
settings::loadBootSettings(boot_properties) &&
!boot_properties.autoStartAppId.empty() &&
app_manager_find_manifest(boot_properties.autoStartAppId.c_str(), &manifest) == ERROR_NONE
) {
} else if (settings::loadBootSettings(boot_properties) &&
!boot_properties.autoStartAppId.empty() &&
app_manager_find_manifest(boot_properties.autoStartAppId.c_str(), &manifest) == ERROR_NONE) {
LOG_I(TAG, "Starting %s", boot_properties.autoStartAppId.c_str());
uint32_t app_launch_id;
app_start(boot_properties.autoStartAppId.c_str(), 0, nullptr, &app_launch_id);
} else {
// No auto-start, consider running system setup
if (!setup::isCompleted()) {
setup::start();
}
} else if (!setup::isCompleted()) {
setup::start();
}
}
int32_t appMain(int argc, char* argv[]) {
uint32_t appInstanceId = app_scheduler_current_app_id();
uint32_t app_instance_id = app_scheduler_current_app_id();
runAutoStart();
LauncherWidgets widgets;
WindowId window = window_manager_create_ext(app_instance_id, createWidgets, destroyWidgets, &widgets);
TaskEventGroup event_group {};
task_event_group_construct(&event_group);
AppEventSubscription sub {};
check(app_event_subscribe(&sub, &event_group) == ERROR_NONE);
WindowId window = window_manager_create(appInstanceId, createWidgets, nullptr);
// The launcher is meant to stay resident (it's the home screen) - it only gives up its
// thread when app-module's scheduler asks it to (e.g. another new-model app is started).
while (true) {
task_event_group_wait_any(&event_group, nullptr, portMAX_DELAY);
bool shouldClose = false;
bool should_close = false;
AppEvent event {};
while (app_event_poll(&sub, &event) == ERROR_NONE) {
if (event.type == APP_EVENT_CLOSE) {
shouldClose = true;
should_close = true;
break;
}
}
if (shouldClose) break;
if (should_close) break;
}
window_manager_remove(window);
@@ -275,16 +362,13 @@ extern const ::AppManifest manifest = {
.category = APP_CATEGORY_SYSTEM,
.location = { .type = APP_LOCATION_MEMORY, .location = reinterpret_cast<void*>(appMain) },
.flags = APP_MANIFEST_FLAG_HIDDEN,
// No file IO, so callstack can be in external RAM
.stack = { .depth = 3072 , .desired_memory_capability = MEMORY_CAPABILITY_EXTERNAL }
.stack = { .depth = 3072, .desired_memory_capability = MEMORY_CAPABILITY_EXTERNAL }
};
// Kept for Tactility/Private/Tactility/app/launcher/Launcher.h's existing declaration (still
// used by the old, unconverted CrashDiagnostics app to return to the launcher after a crash).
uint32_t start() {
uint32_t instance_id = 0;
app_start(manifest.id, 0, nullptr, &instance_id);
return instance_id;
}
} // namespace
} // namespace tt::app::launcher
Tactility/Source/app/mcpsettings/McpSettingsApp.cpp
+98
View File
@@ -0,0 +1,98 @@
#ifdef ESP_PLATFORM
#include <Tactility/Tactility.h>
#include <Tactility/lvgl/Lvgl.h>
#include <Tactility/settings/McpSettings.h>
#include <Tactility/settings/WebServerSettings.h>
#include <Tactility/service/webserver/WebServerService.h>
#include <app/event.h>
#include <app/manifest.h>
#include <app/scheduler.h>
#include <lvgl_window_manager/window_manager.h>
#include <lvgl/widgets/toolbar.h>
#include <lvgl/lvgl.h>
#include <tactility/check.h>
#include <tactility/log.h>
#include <esp_netif.h>
#include <lvgl.h>
#include <string>
namespace tt::app::mcpsettings {
constexpr auto* TAG = "McpSettingsApp";
extern const ::AppManifest manifest;
namespace {
struct Context {
uint32_t appInstanceId;
settings::mcp::McpSettings mcpSettings;
settings::webserver::WebServerSettings wsSettings;
bool updated = false;
lv_obj_t* switchMcpEnabled = nullptr;
lv_obj_t* labelUrlValue = nullptr;
};
void updateUrlDisplay(Context* ctx) {
if (ctx->labelUrlValue == nullptr) return;
if (!ctx->mcpSettings.mcpEnabled) { lv_label_set_text(ctx->labelUrlValue, "Disabled"); return; }
std::string url = "http://";
bool ipAdded = false;
for (const char* key : {"WIFI_STA_DEF", "WIFI_AP_DEF"}) {
auto* netif = esp_netif_get_handle_from_ifkey(key);
if (netif != nullptr) {
esp_netif_ip_info_t info;
if (esp_netif_get_ip_info(netif, &info) == ESP_OK && info.ip.addr != 0) {
char ip[16]; snprintf(ip, sizeof(ip), IPSTR, IP2STR(&info.ip));
url += ip; ipAdded = true; break;
}
}
}
if (!ipAdded) url += ctx->wsSettings.wifiMode == settings::webserver::WiFiMode::AccessPoint ? "192.168.4.1" : "Connecting...";
if (url.starts_with("http://") && ctx->wsSettings.webServerPort != 80) url += ":" + std::to_string(ctx->wsSettings.webServerPort);
url += "/api/mcp";
lv_label_set_text(ctx->labelUrlValue, url.c_str());
}
void onBackPressed(lv_event_t* event) {
auto* ctx = static_cast<Context*>(lv_event_get_user_data(event));
app_event_emit_close(ctx->appInstanceId);
}
void onMcpEnabledSwitch(lv_event_t* event) {
auto* ctx = static_cast<Context*>(lv_event_get_user_data(event));
const bool enabled = lv_obj_has_state(ctx->switchMcpEnabled, LV_STATE_CHECKED);
getMainDispatcher().dispatch([ctx, enabled] {
ctx->mcpSettings.mcpEnabled = enabled; ctx->updated = true;
lvgl_lock(); updateUrlDisplay(ctx); lvgl_unlock();
if (!settings::mcp::save(ctx->mcpSettings)) LOG_W(TAG, "Failed to persist MCP settings");
service::webserver::getPubsub()->publish(service::webserver::WebServerEvent::WebServerSettingsChanged);
service::webserver::setWebServerEnabled(enabled);
});
}
void createWidgets(lv_obj_t* parent, void* userData) {
auto* ctx = static_cast<Context*>(userData);
ctx->wsSettings = settings::webserver::loadOrGetDefault();
lv_obj_set_flex_flow(parent, LV_FLEX_FLOW_COLUMN);
lv_obj_set_style_pad_row(parent, 0, LV_STATE_DEFAULT);
auto* toolbar = lvgl_toolbar_create(parent, "MCP Settings");
lvgl_toolbar_set_nav_action(toolbar, LV_SYMBOL_CLOSE, onBackPressed, ctx);
ctx->switchMcpEnabled = lvgl_toolbar_add_switch_action(toolbar);
if (ctx->mcpSettings.mcpEnabled) lv_obj_add_state(ctx->switchMcpEnabled, LV_STATE_CHECKED);
lv_obj_add_event_cb(ctx->switchMcpEnabled, onMcpEnabledSwitch, LV_EVENT_VALUE_CHANGED, ctx);
auto* main = lv_obj_create(parent); lv_obj_set_flex_flow(main, LV_FLEX_FLOW_COLUMN); lv_obj_set_width(main, LV_PCT(100)); lv_obj_set_flex_grow(main, 1);
auto* wrapper = lv_obj_create(main); lv_obj_set_size(wrapper, LV_PCT(100), LV_SIZE_CONTENT); lv_obj_set_style_pad_all(wrapper, 10, LV_STATE_DEFAULT); lv_obj_set_style_border_width(wrapper, 1, LV_STATE_DEFAULT); lv_obj_set_flex_flow(wrapper, LV_FLEX_FLOW_COLUMN); lv_obj_set_style_flex_cross_place(wrapper, LV_FLEX_ALIGN_START, 0);
auto* title = lv_label_create(wrapper); lv_label_set_text(title, "MCP Endpoint URL:");
ctx->labelUrlValue = lv_label_create(wrapper); updateUrlDisplay(ctx);
auto* info = lv_label_create(main); lv_label_set_long_mode(info, LV_LABEL_LONG_WRAP); lv_obj_set_width(info, LV_PCT(95));
lv_label_set_text(info, "MCP (Model Context Protocol) Screen service allows LLMs to interact with the device screen, audio, and tools directly.\n\nEndpoints:\n- POST /api/mcp (JSON-RPC tools)\n- POST /api/screen/raw (big-endian RGB565 writes)\n\nTo show the LLM canvas, select 'MCP Screen' in Settings -> Display -> Screensaver. The canvas also pops up automatically when an LLM sends a draw command.");
}
int32_t appMain(int, char**) {
Context ctx{}; ctx.appInstanceId = app_scheduler_current_app_id(); ctx.mcpSettings = settings::mcp::loadOrGetDefault();
TaskEventGroup group{}; task_event_group_construct(&group); AppEventSubscription sub{}; check(app_event_subscribe(&sub, &group) == ERROR_NONE);
auto window = window_manager_create(ctx.appInstanceId, createWidgets, &ctx); bool close = false;
while (!close) { task_event_group_wait_any(&group, nullptr, portMAX_DELAY); AppEvent event{}; while (app_event_poll(&sub, &event) == ERROR_NONE) if (event.type == APP_EVENT_CLOSE) { close = true; break; } }
window_manager_remove(window); check(app_event_unsubscribe(&sub) == ERROR_NONE); task_event_group_destruct(&group); return 0;
}
}
extern const ::AppManifest manifest = { .id = "McpSettings", .name = "MCP Screen", .category = APP_CATEGORY_SETTINGS, .location = { APP_LOCATION_MEMORY, reinterpret_cast<void*>(appMain) }, .flags = 0, .stack = { .depth = 8192, .desired_memory_capability = 0 } };
}
#endif
Tactility/Source/app/settings/Settings.cpp
+1 -1
View File
@@ -118,7 +118,7 @@ extern const ::AppManifest manifest = {
.category = APP_CATEGORY_SYSTEM,
.location = { .type = APP_LOCATION_MEMORY, .location = reinterpret_cast<void*>(appMain) },
.flags = APP_MANIFEST_FLAG_HIDDEN,
.stack = { .depth = 2400, .desired_memory_capability = 0 },
.stack = { .depth = 3072, .desired_memory_capability = 0 },
};
} // namespace
Tactility/Source/lvgl/Lvgl.cpp
+52
View File
@@ -0,0 +1,52 @@
#include <Tactility/lvgl/Lvgl.h>
#include <Tactility/settings/DisplaySettings.h>
#include <lvgl/fonts.h>
#include <lvgl/lvgl.h>
namespace tt::lvgl {
void applyFontSize(settings::display::FontSize fontSize) {
LvglFontScale scale;
switch (fontSize) {
using enum settings::display::FontSize;
case Small:
scale = FONT_SCALE_SMALL;
break;
case Large:
scale = FONT_SCALE_LARGE;
break;
case Default:
default:
scale = FONT_SCALE_DEFAULT;
break;
}
lvgl_set_text_font_scale(scale);
const lv_font_t* font = lvgl_get_text_font(FONT_SIZE_DEFAULT);
for (lv_display_t* display = lv_display_get_next(nullptr);
display != nullptr;
display = lv_display_get_next(display)) {
#if LV_USE_THEME_DEFAULT
if (lv_display_get_theme(display) == lv_theme_default_get()) {
lv_obj_t* screen = lv_display_get_screen_active(display);
lv_theme_default_init(
display,
lv_theme_get_color_primary(screen),
lv_theme_get_color_secondary(screen),
LV_THEME_DEFAULT_DARK,
font
);
}
#endif
// The display layers are independent inheritance roots. Updating all of them makes
// the new size visible immediately in regular screens, overlays, and the status bar.
lv_obj_set_style_text_font(lv_display_get_screen_active(display), font, LV_PART_MAIN);
lv_obj_set_style_text_font(lv_display_get_layer_top(display), font, LV_PART_MAIN);
lv_obj_set_style_text_font(lv_display_get_layer_sys(display), font, LV_PART_MAIN);
lv_obj_set_style_text_font(lv_display_get_layer_bottom(display), font, LV_PART_MAIN);
}
}
} // namespace tt::lvgl
Tactility/Source/mcp/McpSystem.cpp
+2000
View File
File diff suppressed because it is too large Load Diff
Tactility/Source/service/displayidle/DisplayIdle.cpp
+48
View File
@@ -3,10 +3,12 @@
#include <Tactility/service/displayidle/DisplayIdleService.h>
#include <Tactility/service/ServiceManifest.h>
#include <Tactility/service/ServiceRegistration.h>
#include <Tactility/mcp/McpSystem.h>
#include "BouncingBallsScreensaver.h"
#include "MatrixRainScreensaver.h"
#include "MystifyScreensaver.h"
#include "McpScreensaver.h"
#include "Screensaver.h"
#include "StackChanScreensaver.h"
@@ -127,6 +129,9 @@ void DisplayIdleService::activateScreensaver() {
case settings::display::ScreensaverType::StackChan:
screensaver = std::make_unique<StackChanScreensaver>();
break;
case settings::display::ScreensaverType::McpScreen:
screensaver = std::make_unique<McpScreensaver>();
break;
case settings::display::ScreensaverType::None:
default:
// Just black screen, no animated screensaver
@@ -273,6 +278,49 @@ bool DisplayIdleService::isScreensaverActive() const {
return screensaverOverlay != nullptr;
}
void DisplayIdleService::startMcpScreensaver() {
if (!lvgl_try_lock(200)) {
LOG_W(TAG, "startMcpScreensaver: failed to acquire LVGL lock");
return;
}
if (screensaverOverlay != nullptr) {
const auto& mcpState = mcp::getState();
if (mcpState.drawArea != nullptr) {
lvgl_unlock();
return;
}
if (screensaver) {
screensaver->stop();
screensaver.reset();
}
lv_obj_delete(screensaverOverlay);
screensaverOverlay = nullptr;
}
screensaverActiveCounter = 0;
backlightOff = false;
setBacklightBrightness(cachedDisplaySettings.backlightDuty == 0
? 255 : cachedDisplaySettings.backlightDuty);
lv_coord_t screenW = lv_display_get_horizontal_resolution(nullptr);
lv_coord_t screenH = lv_display_get_vertical_resolution(nullptr);
screensaverOverlay = lv_obj_create(lv_layer_top());
lv_obj_remove_style_all(screensaverOverlay);
lv_obj_set_size(screensaverOverlay, LV_PCT(100), LV_PCT(100));
lv_obj_set_pos(screensaverOverlay, 0, 0);
lv_obj_set_style_bg_color(screensaverOverlay, lv_color_black(), 0);
lv_obj_set_style_bg_opa(screensaverOverlay, LV_OPA_COVER, 0);
lv_obj_add_flag(screensaverOverlay, LV_OBJ_FLAG_CLICKABLE);
lv_obj_add_event_cb(screensaverOverlay, stopScreensaverCb, LV_EVENT_CLICKED, this);
screensaver = std::make_unique<McpScreensaver>();
screensaver->start(screensaverOverlay, screenW, screenH);
lvgl_unlock();
displayDimmed = true;
LOG_I(TAG, "MCP screensaver activated");
}
void DisplayIdleService::reloadSettings() {
// Set flag for thread-safe reload - actual reload happens in tick()
settingsReloadRequested.store(true, std::memory_order_release);
Tactility/Source/service/displayidle/McpScreensaver.cpp
+100
View File
@@ -0,0 +1,100 @@
#ifdef ESP_PLATFORM
#include "McpScreensaver.h"
#include <Tactility/mcp/McpSystem.h>
#include <tactility/log.h>
constexpr auto* TAG = "McpScreensaver";
#include <esp_heap_caps.h>
namespace tt::service::displayidle {
void McpScreensaver::start(lv_obj_t* overlay, lv_coord_t screenW, lv_coord_t screenH) {
auto& state = mcp::getState();
// Full-screen canvas on the overlay
lv_obj_t* canvas = lv_canvas_create(overlay);
lv_obj_set_size(canvas, screenW, screenH);
lv_obj_set_pos(canvas, 0, 0);
lv_obj_set_style_radius(canvas, 0, LV_PART_MAIN);
lv_obj_set_style_border_width(canvas, 0, LV_PART_MAIN);
lv_obj_set_style_pad_all(canvas, 0, LV_PART_MAIN);
lv_obj_remove_flag(canvas, LV_OBJ_FLAG_SCROLLABLE);
// Allocate framebuffer (prefer SPIRAM)
size_t requiredSize = (size_t)screenW * screenH * sizeof(uint16_t);
framebuffer = (uint16_t*)heap_caps_malloc(requiredSize, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
if (framebuffer == nullptr) {
framebuffer = (uint16_t*)heap_caps_malloc(requiredSize, MALLOC_CAP_8BIT);
}
framebufferSize = (framebuffer != nullptr) ? requiredSize : 0;
if (framebuffer == nullptr) {
LOG_E(TAG, "Failed to allocate %uB framebuffer", (unsigned)requiredSize);
lv_obj_t* err = lv_label_create(canvas);
lv_label_set_text(err, "Framebuffer alloc failed");
lv_obj_center(err);
return;
}
// Fill with a dark slate background (inverted for display path)
size_t pixelCount = (size_t)screenW * screenH;
for (size_t i = 0; i < pixelCount; ++i) {
framebuffer[i] = ~0x18E3; // dark blue-grey
}
lv_canvas_set_buffer(canvas, framebuffer, screenW, screenH, LV_COLOR_FORMAT_RGB565);
// Waiting label (removed on first MCP draw via lv_obj_clean)
lv_obj_t* waitLabel = lv_label_create(canvas);
lv_label_set_text(waitLabel, "Waiting for LLM...");
lv_obj_set_style_text_color(waitLabel, lv_color_black(), LV_PART_MAIN); // white on screen (inverted)
lv_obj_align(waitLabel, LV_ALIGN_CENTER, 0, -20);
lv_obj_t* resLabel = lv_label_create(canvas);
lv_label_set_text_fmt(resLabel, "Display: %dx%d", (int)screenW, (int)screenH);
lv_color_t resColor = lv_palette_lighten(LV_PALETTE_BLUE, 3);
lv_obj_set_style_text_color(resLabel, lv_color_make(~resColor.red, ~resColor.green, ~resColor.blue), LV_PART_MAIN);
lv_obj_align(resLabel, LV_ALIGN_CENTER, 0, 10);
// Register with McpSystemState
std::lock_guard<std::mutex> lock(state.mutex);
state.drawArea = canvas;
state.framebuffer = framebuffer;
state.framebufferSize = framebufferSize;
state.displayWidth = (uint16_t)screenW;
state.displayHeight = (uint16_t)screenH;
state.drawWidth = (uint16_t)screenW;
state.drawHeight = (uint16_t)screenH;
// Don't reset overrideActive — if the LLM already drew, we keep the content
LOG_I(TAG, "McpScreensaver started (%dx%d)", (int)screenW, (int)screenH);
}
void McpScreensaver::stop() {
auto& state = mcp::getState();
{
std::lock_guard<std::mutex> lock(state.mutex);
state.drawArea = nullptr;
state.framebuffer = nullptr;
state.framebufferSize = 0;
state.overrideActive = false;
}
if (framebuffer != nullptr) {
heap_caps_free(framebuffer);
framebuffer = nullptr;
framebufferSize = 0;
}
LOG_I(TAG, "McpScreensaver stopped");
}
void McpScreensaver::update(lv_coord_t /*screenW*/, lv_coord_t /*screenH*/) {
// MCP draws on demand via HTTP — no per-frame animation needed
}
} // namespace tt::service::displayidle
#endif // ESP_PLATFORM
Tactility/Source/service/displayidle/McpScreensaver.h
+30
View File
@@ -0,0 +1,30 @@
#pragma once
#ifdef ESP_PLATFORM
#include "Screensaver.h"
#include <cstdint>
namespace tt::service::displayidle {
/**
* MCP Screen screensaver.
* Creates a full-screen LVGL canvas on the overlay and registers it in
* McpSystemState so that MCP HTTP draw commands can paint to it.
* Dismissed by a touch event (handled by the parent DisplayIdle overlay).
*/
class McpScreensaver final : public Screensaver {
uint16_t* framebuffer = nullptr;
size_t framebufferSize = 0;
public:
McpScreensaver() = default;
~McpScreensaver() override = default;
void start(lv_obj_t* overlay, lv_coord_t screenW, lv_coord_t screenH) override;
void stop() override;
void update(lv_coord_t screenW, lv_coord_t screenH) override;
};
} // namespace tt::service::displayidle
#endif // ESP_PLATFORM
Tactility/Source/service/webserver/McpHandler.cpp
+1019
View File
File diff suppressed because it is too large Load Diff
Tactility/Source/service/webserver/WebServerService.cpp
+31 -1
View File
@@ -32,6 +32,8 @@
#include "app/manager.h"
#ifdef ESP_PLATFORM
#include <Tactility/mcp/McpSystem.h>
#include <Tactility/settings/McpSettings.h>
#include <esp_chip_info.h>
#include <esp_flash.h>
#include <esp_heap_caps.h>
@@ -213,7 +215,7 @@ bool WebServerService::onStart(ServiceContext& service) {
lock.lock();
g_cachedSettings = settings::webserver::loadOrGetDefault();
g_settingsCached = true;
serverEnabled = g_cachedSettings.webServerEnabled;
serverEnabled = g_cachedSettings.webServerEnabled || settings::mcp::loadOrGetDefault().mcpEnabled;
}
// Subscribe to settings change events to refresh cache
settingsEventSubscription = pubsub->subscribe([](WebServerEvent event) {
@@ -222,6 +224,10 @@ bool WebServerService::onStart(ServiceContext& service) {
lock.lock();
g_cachedSettings = settings::webserver::loadOrGetDefault();
g_settingsCached = true;
const bool enabled = g_cachedSettings.webServerEnabled || settings::mcp::loadOrGetDefault().mcpEnabled;
if (g_webServerInstance.load() != nullptr) {
g_webServerInstance.load()->setEnabled(enabled);
}
}
});
@@ -481,6 +487,21 @@ bool WebServerService::startServer() {
.callback = handleAdminPost,
.user_ctx = ctx
},
#ifdef ESP_PLATFORM
// MCP is LAN-local and is enabled whenever the web server is enabled.
{
.uri = "/api/mcp",
.method = HTTP_METHOD_POST,
.callback = handleApiMcp,
.user_ctx = ctx
},
{
.uri = "/api/screen/raw",
.method = HTTP_METHOD_POST,
.callback = handleApiScreenRaw,
.user_ctx = ctx
},
#endif
// API endpoints for system info, apps, wifi, etc
{
.uri = "/api/*",
@@ -528,6 +549,12 @@ bool WebServerService::startServer() {
LOG_I(TAG, "HTTP server started successfully on port %u", (unsigned)settings.webServerPort);
publish_event(this, WebServerEvent::WebServerStarted);
#ifdef ESP_PLATFORM
if (settings::mcp::loadOrGetDefault().mcpEnabled) {
mcp::startVideoStreamServer();
}
#endif
// Show statusbar icon
if (statusbarIconId >= 0) {
lvgl::statusbar_icon_set_image(statusbarIconId, LVGL_ICON_STATUSBAR_CLOUD);
@@ -544,6 +571,9 @@ void WebServerService::stopServer() {
return;
}
#ifdef ESP_PLATFORM
mcp::stopVideoStreamServer();
#endif
http_server_free(httpServer);
httpServer = nullptr;
Tactility/Source/settings/DisplaySettings.cpp
+43
View File
@@ -20,6 +20,7 @@ static std::string getSettingsFilePath() {
}
constexpr auto* SETTINGS_KEY_ORIENTATION = "orientation";
constexpr auto* SETTINGS_KEY_FONT_SIZE = "fontSize";
constexpr auto* SETTINGS_KEY_GAMMA_CURVE = "gammaCurve";
constexpr auto* SETTINGS_KEY_BACKLIGHT_DUTY = "backlightDuty";
constexpr auto* SETTINGS_KEY_TIMEOUT_ENABLED = "backlightTimeoutEnabled";
@@ -73,6 +74,34 @@ static bool fromString(const std::string& str, Orientation& orientation) {
}
}
static std::string toString(FontSize font_size) {
switch (font_size) {
using enum FontSize;
case Small:
return "Small";
case Default:
return "Default";
case Large:
return "Large";
default:
std::unreachable();
}
}
static bool fromString(const std::string& str, FontSize& font_size) {
if (str == "Small") {
font_size = FontSize::Small;
return true;
} else if (str == "Default") {
font_size = FontSize::Default;
return true;
} else if (str == "Large") {
font_size = FontSize::Large;
return true;
}
return false;
}
static std::string toString(ScreensaverType type) {
switch (type) {
using enum ScreensaverType;
@@ -86,6 +115,8 @@ static std::string toString(ScreensaverType type) {
return "MatrixRain";
case StackChan:
return "StackChan";
case McpScreen:
return "McpScreen";
default:
std::unreachable();
}
@@ -107,6 +138,9 @@ static bool fromString(const std::string& str, ScreensaverType& type) {
} else if (str == "StackChan") {
type = ScreensaverType::StackChan;
return true;
} else if (str == "McpScreen") {
type = ScreensaverType::McpScreen;
return true;
} else {
return false;
}
@@ -129,6 +163,12 @@ bool load(DisplaySettings& settings) {
orientation = getDefaultOrientation();
}
auto font_size_entry = map.find(SETTINGS_KEY_FONT_SIZE);
FontSize font_size = FontSize::Default;
if (font_size_entry != map.end()) {
fromString(font_size_entry->second, font_size);
}
auto gamma_entry = map.find(SETTINGS_KEY_GAMMA_CURVE);
int gamma_curve = 0;
if (gamma_entry != map.end()) {
@@ -163,6 +203,7 @@ bool load(DisplaySettings& settings) {
}
settings.orientation = orientation;
settings.fontSize = font_size;
settings.gammaCurve = gamma_curve;
settings.backlightDuty = backlight_duty;
settings.backlightTimeoutEnabled = timeout_enabled;
@@ -175,6 +216,7 @@ bool load(DisplaySettings& settings) {
DisplaySettings getDefault() {
return DisplaySettings {
.orientation = getDefaultOrientation(),
.fontSize = FontSize::Default,
.gammaCurve = 1,
.backlightDuty = 200,
.backlightTimeoutEnabled = false,
@@ -196,6 +238,7 @@ bool save(const DisplaySettings& settings) {
map[SETTINGS_KEY_BACKLIGHT_DUTY] = std::to_string(settings.backlightDuty);
map[SETTINGS_KEY_GAMMA_CURVE] = std::to_string(settings.gammaCurve);
map[SETTINGS_KEY_ORIENTATION] = toString(settings.orientation);
map[SETTINGS_KEY_FONT_SIZE] = toString(settings.fontSize);
map[SETTINGS_KEY_TIMEOUT_ENABLED] = settings.backlightTimeoutEnabled ? "1" : "0";
map[SETTINGS_KEY_TIMEOUT_MS] = std::to_string(settings.backlightTimeoutMs);
map[SETTINGS_KEY_SCREENSAVER_TYPE] = toString(settings.screensaverType);
Tactility/Source/settings/McpSettings.cpp
+76
View File
@@ -0,0 +1,76 @@
#include <Tactility/settings/McpSettings.h>
#include <Tactility/file/PropertiesFile.h>
#include <Tactility/file/File.h>
#include <tactility/log.h>
#include <app/paths.h>
constexpr auto* TAG = "McpSettings";
#include <map>
#include <string>
namespace tt::settings::mcp {
static std::string getSettingsFilePath() {
char path[256];
if (app_paths_get_user_data_path("tactility.mcpsettings", "mcp.properties", path, sizeof(path)) != ERROR_NONE) {
return "";
}
return path;
}
constexpr auto* KEY_MCP_ENABLED = "mcpEnabled";
bool load(McpSettings& settings) {
auto settings_path = getSettingsFilePath();
if (!file::isFile(settings_path)) {
return false;
}
std::map<std::string, std::string> map;
if (!file::loadPropertiesFile(settings_path, map)) {
return false;
}
auto mcp_enabled = map.find(KEY_MCP_ENABLED);
settings.mcpEnabled = (mcp_enabled != map.end())
? (mcp_enabled->second == "1" || mcp_enabled->second == "true")
: false;
return true;
}
McpSettings getDefault() {
return McpSettings{
.mcpEnabled = false
};
}
McpSettings loadOrGetDefault() {
McpSettings settings;
if (!load(settings)) {
settings = getDefault();
if (!save(settings)) {
LOG_W(TAG, "Failed to save default MCP settings");
}
}
return settings;
}
bool save(const McpSettings& settings) {
std::map<std::string, std::string> map;
map[KEY_MCP_ENABLED] = settings.mcpEnabled ? "true" : "false";
auto settings_path = getSettingsFilePath();
if (!file::findOrCreateParentDirectory(settings_path, 0755)) {
LOG_E(TAG, "Failed to create parent dir for %s", settings_path.c_str());
return false;
}
if (!file::savePropertiesFile(settings_path, map)) {
LOG_E(TAG, "Failed to save MCP settings to %s", settings_path.c_str());
return false;
}
return true;
}
} // namespace