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

feat(mcp): restore MCP system with native log.h

Browse Source 
- MCP 3.3K LOC: McpSystem 1899 + McpHandler 1029 + McpScreensaver + 2 apps
- Uses native tactility/log.h TAG macros, no old Logger.h
- DisplaySettings McpScreen enum, WebServer coexistence (MCP enabled starts HTTP)
- DisplayIdle: startMcpScreensaver + isDeviceCharging + lock inversion fix 3629ffef
- LVGL 512K PSRAM cache retained from previous perf patch
- Audio kept upstream es8311-module per note we might not need custom
This commit is contained in:
Adolfo Reyna
2026-07-18 17:29:37 -04:00
parent c4adaef0a5
commit e3eb3fd415
15 changed files with 5568 additions and 26 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Tactility/Source/service/displayidle/DisplayIdle.cpp
+108 -21
View File
@@ -1,4 +1,5 @@
#ifdef ESP_PLATFORM
#include <tactility/log.h>
#include <Tactility/service/displayidle/DisplayIdleService.h>
@@ -7,8 +8,8 @@
#include "MatrixRainScreensaver.h"
#include "MystifyScreensaver.h"
#include "StackChanScreensaver.h"
#include "McpScreensaver.h"
#include <tactility/log.h>
#include <Tactility/CoreDefines.h>
#include <Tactility/hal/display/DisplayDevice.h>
#include <Tactility/hal/power/PowerDevice.h>
@@ -16,6 +17,7 @@
#include <Tactility/service/ServiceContext.h>
#include <Tactility/service/ServiceManifest.h>
#include <Tactility/service/ServiceRegistration.h>
#include <Tactility/mcp/McpSystem.h>
#include <cstdlib>
#include <ctime>
@@ -33,32 +35,24 @@ static bool isDeviceCharging() {
bool charging = false;
hal::findDevices<hal::power::PowerDevice>(hal::Device::Type::Power, [&charging](const auto& power) {
if (!power->supportsMetric(hal::power::PowerDevice::MetricType::IsCharging)) {
return true;
return true; // continue
}
hal::power::PowerDevice::MetricData data;
if (power->getMetric(hal::power::PowerDevice::MetricType::IsCharging, data) && data.valueAsBool) {
charging = true;
return false;
return false; // stop iter
}
return true;
});
return charging;
}
void DisplayIdleService::stopScreensaverCb(lv_event_t* e) {
auto* self = static_cast<DisplayIdleService*>(lv_event_get_user_data(e));
lv_event_stop_bubbling(e);
self->stopScreensaverRequested.store(true, std::memory_order_release);
lv_display_trigger_activity(nullptr);
self->stopScreensaverLocked();
}
void DisplayIdleService::stopScreensaver() {
if (!lvgl::lock(100)) {
// Lock failed - keep flag set to retry on next tick
return;
}
void DisplayIdleService::stopScreensaverLocked() {
const auto restoreDuty = cachedDisplaySettings.backlightDuty;
const bool wasDimmed = displayDimmed;
@@ -70,7 +64,6 @@ void DisplayIdleService::stopScreensaver() {
lv_obj_delete(screensaverOverlay);
screensaverOverlay = nullptr;
}
lvgl::unlock();
stopScreensaverRequested.store(false, std::memory_order_relaxed);
// Reset auto-off state
@@ -85,6 +78,15 @@ void DisplayIdleService::stopScreensaver() {
displayDimmed = wasDimmed ? false : displayDimmed;
}
void DisplayIdleService::stopScreensaver() {
if (!lvgl::lock(100)) {
// Lock failed - keep flag set to retry on next tick
return;
}
stopScreensaverLocked();
lvgl::unlock();
}
void DisplayIdleService::activateScreensaver() {
lv_obj_t* top = lv_layer_top();
@@ -121,6 +123,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
@@ -141,8 +146,17 @@ void DisplayIdleService::updateScreensaver() {
}
}
void DisplayIdleService::tick() {
// Check if MCP override is active — must not be auto-stopped by idle logic
// READ OUTSIDE LVGL lock to avoid lock inversion:
// MCP video task locks mutex -> LVGL, we must NOT do LVGL -> mutex
bool isMcpActive = false;
{
auto& st = mcp::getState();
std::lock_guard<std::mutex> lk(st.mutex);
isMcpActive = (st.drawArea != nullptr) || st.overrideActive;
}
if (!lvgl::lock(100)) {
return;
}
@@ -159,11 +173,13 @@ void DisplayIdleService::tick() {
uint32_t inactive_ms = 0;
inactive_ms = lv_display_get_inactive_time(nullptr);
// Only update if not stopping (prevents lag on touch)
if (displayDimmed && screensaverOverlay && !stopScreensaverRequested.load(std::memory_order_acquire)) {
// Only update if not stopping (prevents lag on touch) — skip for MCP (no animation)
if (displayDimmed && screensaverOverlay && !stopScreensaverRequested.load(std::memory_order_acquire) && !isMcpActive) {
// Check if screensaver should auto-off after 5 minutes
if (!backlightOff) {
screensaverActiveCounter++;
if (screensaverActiveCounter >= SCREENSAVER_AUTO_OFF_TICKS) {
// Stop screensaver animation and turn off backlight
if (screensaver) {
screensaver->stop();
screensaver.reset();
@@ -181,6 +197,7 @@ void DisplayIdleService::tick() {
lvgl::unlock();
// Check stop request early for faster response
if (stopScreensaverRequested.load(std::memory_order_acquire)) {
stopScreensaver();
return;
@@ -190,13 +207,15 @@ void DisplayIdleService::tick() {
bool supportsBacklight = display != nullptr && display->supportsBacklightDuty();
if (!cachedDisplaySettings.backlightTimeoutEnabled || cachedDisplaySettings.backlightTimeoutMs == 0) {
if (displayDimmed) {
// Timeout disabled (Never): ensure we restore if we were dimmed, regardless of display type
if (displayDimmed && !isMcpActive) {
if (supportsBacklight && display != nullptr) {
display->setBacklightDuty(cachedDisplaySettings.backlightDuty);
}
displayDimmed = false;
}
} else if (supportsBacklight) {
// For backlight-capable displays: full idle handling
bool charging_blocks = cachedDisplaySettings.disableScreensaverWhenCharging && isDeviceCharging();
if (!displayDimmed && inactive_ms >= cachedDisplaySettings.backlightTimeoutMs) {
@@ -204,7 +223,7 @@ void DisplayIdleService::tick() {
// Skip screensaver while charging
} else {
if (!lvgl::lock(100)) {
return;
return; // Retry on next tick
}
activateScreensaver();
lvgl::unlock();
@@ -215,23 +234,35 @@ void DisplayIdleService::tick() {
}
displayDimmed = true;
}
} else if (displayDimmed) {
} else if (displayDimmed && !isMcpActive) {
if (inactive_ms < kWakeActivityThresholdMs) {
stopScreensaver();
} else if (charging_blocks) {
stopScreensaver();
}
}
} else {
// For monochrome/RLCD (no backlight): don't auto-enter screensaver (heavy full_refresh SPI causes freeze)
// Only handle wake if we are somehow dimmed (e.g. MCP left it)
if (displayDimmed && !isMcpActive) {
if (inactive_ms < kWakeActivityThresholdMs) {
stopScreensaver();
}
}
}
}
bool DisplayIdleService::onStart(ServiceContext& service) {
// Seed random number generator for varied screensaver patterns
srand(static_cast<unsigned int>(time(nullptr)));
cachedDisplaySettings = settings::display::loadOrGetDefault();
auto display = getDisplay();
if (display != nullptr && !display->supportsBacklightDuty()) {
LOG_I(TAG, "Monochrome/RLCD display detected (no backlight control): idle timer will run but auto-backlight off is disabled");
}
timer = std::make_unique<Timer>(Timer::Type::Periodic, kernel::millisToTicks(TICK_INTERVAL_MS), [this]{ this->tick(); });
timer->setCallbackPriority(Thread::Priority::Lower);
timer->start();
@@ -288,6 +319,62 @@ void DisplayIdleService::reloadSettings() {
settingsReloadRequested.store(true, std::memory_order_release);
}
void DisplayIdleService::startMcpScreensaver() {
if (!lvgl::lock(200)) {
LOG_W(TAG, "startMcpScreensaver: failed to acquire LVGL lock");
return;
}
if (screensaverOverlay != nullptr) {
// Screensaver already active — if drawArea is registered we're done,
// otherwise stop the current one so we can replace it with McpScreensaver.
const auto& mcpState = mcp::getState();
if (mcpState.drawArea != nullptr) {
lvgl::unlock();
return; // McpScreensaver already running
}
// Wrong screensaver type active — tear it down first
if (screensaver) {
screensaver->stop();
screensaver.reset();
}
lv_obj_delete(screensaverOverlay);
screensaverOverlay = nullptr;
}
screensaverActiveCounter = 0;
backlightOff = false;
// Ensure backlight is active if the display supports it
auto display = getDisplay();
if (display != nullptr && display->supportsBacklightDuty()) {
uint8_t duty = cachedDisplaySettings.backlightDuty;
if (duty == 0) duty = 255; // ensure visible if settings not loaded / default
display->setBacklightDuty(duty);
}
lv_coord_t screenW = lv_display_get_horizontal_resolution(nullptr);
lv_coord_t screenH = lv_display_get_vertical_resolution(nullptr);
lv_obj_t* top = lv_layer_top();
screensaverOverlay = lv_obj_create(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");
}
std::shared_ptr<DisplayIdleService> findService() {
return std::static_pointer_cast<DisplayIdleService>(
findServiceById("DisplayIdle")