252 lines
7.6 KiB
C++
252 lines
7.6 KiB
C++
// GET /api/devices/screen.png?mac=XX — Render and return a PNG for the device's
|
|
// current screen Uses LVGL to render the device's XML layout (or a fallback
|
|
// label) then encodes to PNG via lodepng.
|
|
|
|
#include "esp_heap_caps.h"
|
|
#include "esp_http_server.h"
|
|
#include "esp_log.h"
|
|
#include "lodepng/lodepng.h"
|
|
#include "lodepng_alloc.hpp"
|
|
#include "lv_setup.hpp"
|
|
#include "lvgl.h"
|
|
#include <string.h>
|
|
|
|
#include "device.hpp"
|
|
#include "types.hpp"
|
|
|
|
internal const char *kTagDeviceScreenImage = "API_DEV_SCREEN_IMG";
|
|
|
|
internal esp_err_t api_devices_screen_image_handler(httpd_req_t *req)
|
|
{
|
|
httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
|
|
httpd_resp_set_hdr(req, "Cache-Control",
|
|
"no-cache, no-store, must-revalidate");
|
|
httpd_resp_set_type(req, "image/png");
|
|
|
|
// Extract mac query parameter
|
|
char mac[18] = {};
|
|
size_t buf_len = httpd_req_get_url_query_len(req) + 1;
|
|
if (buf_len > 1)
|
|
{
|
|
char query[64] = {};
|
|
if (httpd_req_get_url_query_str(req, query, sizeof(query)) == ESP_OK)
|
|
{
|
|
httpd_query_key_value(query, "mac", mac, sizeof(mac));
|
|
}
|
|
}
|
|
|
|
if (mac[0] == '\0')
|
|
{
|
|
httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST,
|
|
"Missing 'mac' query param");
|
|
return ESP_FAIL;
|
|
}
|
|
|
|
device_t *dev = find_device(mac);
|
|
if (!dev)
|
|
{
|
|
httpd_resp_send_err(req, HTTPD_404_NOT_FOUND, "Device not registered");
|
|
return ESP_FAIL;
|
|
}
|
|
|
|
// --- LVGL rendering (mutex-protected) ---
|
|
if (xSemaphoreTake(g_LvglMutex, pdMS_TO_TICKS(5000)) != pdTRUE)
|
|
{
|
|
ESP_LOGE(kTagDeviceScreenImage, "Failed to get LVGL mutex");
|
|
httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "LVGL busy");
|
|
return ESP_FAIL;
|
|
}
|
|
|
|
lv_obj_t *scr = lv_screen_active();
|
|
|
|
// Clear all children from the active screen
|
|
lv_obj_clean(scr);
|
|
|
|
// White background for grayscale
|
|
lv_obj_set_style_bg_color(scr, lv_color_white(), LV_PART_MAIN);
|
|
|
|
// Setup the MAC address subject so the XML can bind to it
|
|
static lv_subject_t mac_subject;
|
|
// Two buffers are needed by LVGL for string observers (current and previous)
|
|
static char mac_buf[18];
|
|
static char mac_prev_buf[18];
|
|
|
|
strncpy(mac_buf, mac, sizeof(mac_buf));
|
|
strncpy(mac_prev_buf, mac, sizeof(mac_prev_buf));
|
|
|
|
lv_subject_init_string(&mac_subject, mac_buf, mac_prev_buf, sizeof(mac_buf),
|
|
mac);
|
|
|
|
// Register the subject in the global XML scope under the name "device_mac"
|
|
lv_xml_component_scope_t *global_scope =
|
|
lv_xml_component_get_scope("globals");
|
|
if (global_scope)
|
|
{
|
|
lv_xml_register_subject(global_scope, "device_mac", &mac_subject);
|
|
ESP_LOGI(kTagDeviceScreenImage,
|
|
"Registered subject 'device_mac' with value: %s", mac);
|
|
}
|
|
|
|
bool render_success = false;
|
|
|
|
// 1. Wrap the payload in a <component><view> if it's missing (LVGL 9.4
|
|
// requirement for register_component_from_data)
|
|
char xml_buffer[2500];
|
|
const char *xml_to_register = (const char *)dev->xml_layout;
|
|
|
|
if (strstr(xml_to_register, "<view") == NULL &&
|
|
strstr(xml_to_register, "<screen") == NULL)
|
|
{
|
|
snprintf(xml_buffer, sizeof(xml_buffer),
|
|
"<component>\n<view width=\"100%%\" "
|
|
"height=\"100%%\">\n%s\n</view>\n</component>",
|
|
dev->xml_layout);
|
|
xml_to_register = xml_buffer;
|
|
ESP_LOGI(kTagDeviceScreenImage,
|
|
"Wrapped widget XML in component/view for parsing.");
|
|
}
|
|
|
|
// 2. Register the XML payload as a component
|
|
lv_result_t res =
|
|
lv_xml_register_component_from_data("current_device", xml_to_register);
|
|
|
|
if (res == LV_RESULT_OK)
|
|
{
|
|
ESP_LOGI(kTagDeviceScreenImage, "Successfully registered XML for device %s",
|
|
mac);
|
|
|
|
// 3. Determine if this XML describes a full <screen> or just a <component>
|
|
// layout Simple heuristic: check if the string contains "<screen"
|
|
if (strstr(xml_to_register, "<screen") != NULL)
|
|
{
|
|
ESP_LOGI(kTagDeviceScreenImage,
|
|
"XML contains <screen>, creating screen instance");
|
|
lv_obj_t *new_scr = lv_xml_create_screen("current_device");
|
|
|
|
if (new_scr)
|
|
{
|
|
// We must load this newly created screen to make it active before
|
|
// rendering
|
|
lv_screen_load(new_scr);
|
|
scr = new_scr; // Update local pointer since active screen changed
|
|
render_success = true;
|
|
}
|
|
else
|
|
{
|
|
ESP_LOGE(kTagDeviceScreenImage,
|
|
"lv_xml_create_screen failed for device %s", mac);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ESP_LOGI(kTagDeviceScreenImage,
|
|
"XML is a component/widget, creating on active screen");
|
|
// Create the component directly on the currently active cleaned screen
|
|
lv_obj_t *comp = (lv_obj_t *)lv_xml_create(scr, "current_device", NULL);
|
|
if (comp)
|
|
{
|
|
render_success = true;
|
|
}
|
|
else
|
|
{
|
|
ESP_LOGE(kTagDeviceScreenImage, "lv_xml_create failed for device %s",
|
|
mac);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ESP_LOGE(kTagDeviceScreenImage,
|
|
"lv_xml_register_component_from_data failed for device %s", mac);
|
|
}
|
|
|
|
// 3. Fallback if LVGL XML parsing or creation failed
|
|
if (!render_success)
|
|
{
|
|
ESP_LOGW(kTagDeviceScreenImage,
|
|
"XML render failed, falling back to raw text layout");
|
|
lv_obj_t *label = lv_label_create(scr);
|
|
lv_label_set_text(label, "XML Parsing Error\nSee serial log");
|
|
lv_obj_set_style_text_color(label, lv_color_black(), LV_PART_MAIN);
|
|
lv_obj_align(label, LV_ALIGN_CENTER, 0, 0);
|
|
}
|
|
|
|
// Force LVGL to fully render the screen
|
|
lv_refr_now(g_LvglDisplay);
|
|
|
|
lv_draw_buf_t *draw_buf = lv_display_get_buf_active(g_LvglDisplay);
|
|
if (!draw_buf)
|
|
{
|
|
xSemaphoreGive(g_LvglMutex);
|
|
ESP_LOGE(kTagDeviceScreenImage, "No active draw buffer");
|
|
httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR,
|
|
"Display uninitialized");
|
|
return ESP_FAIL;
|
|
}
|
|
|
|
uint32_t width = CONFIG_CALENDINK_DISPLAY_WIDTH;
|
|
uint32_t height = CONFIG_CALENDINK_DISPLAY_HEIGHT;
|
|
|
|
// Handle stride != width
|
|
uint8_t *packed_data = (uint8_t *)draw_buf->data;
|
|
bool needs_free = false;
|
|
|
|
if (draw_buf->header.stride != width)
|
|
{
|
|
packed_data =
|
|
(uint8_t *)heap_caps_malloc(width * height, MALLOC_CAP_SPIRAM);
|
|
if (!packed_data)
|
|
{
|
|
xSemaphoreGive(g_LvglMutex);
|
|
ESP_LOGE(kTagDeviceScreenImage, "Failed to allocate packed buffer");
|
|
httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR,
|
|
"Out of memory");
|
|
return ESP_FAIL;
|
|
}
|
|
needs_free = true;
|
|
for (uint32_t y = 0; y < height; ++y)
|
|
{
|
|
memcpy(packed_data + (y * width),
|
|
(uint8_t *)draw_buf->data + (y * draw_buf->header.stride), width);
|
|
}
|
|
}
|
|
|
|
// Encode to PNG
|
|
unsigned char *png = nullptr;
|
|
size_t pngsize = 0;
|
|
|
|
lodepng_allocator_reset();
|
|
|
|
ESP_LOGI(kTagDeviceScreenImage, "Encoding %lux%lu PNG for device %s", width,
|
|
height, mac);
|
|
unsigned error = lodepng_encode_memory(&png, &pngsize, packed_data, width,
|
|
height, LCT_GREY, 8);
|
|
|
|
if (needs_free)
|
|
{
|
|
free(packed_data);
|
|
}
|
|
|
|
xSemaphoreGive(g_LvglMutex);
|
|
|
|
if (error)
|
|
{
|
|
ESP_LOGE(kTagDeviceScreenImage, "PNG encoding error %u: %s", error,
|
|
lodepng_error_text(error));
|
|
httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR,
|
|
"PNG generation failed");
|
|
return ESP_FAIL;
|
|
}
|
|
|
|
ESP_LOGI(kTagDeviceScreenImage, "PNG ready: %zu bytes. Sending...", pngsize);
|
|
esp_err_t sendRes = httpd_resp_send(req, (const char *)png, pngsize);
|
|
|
|
return sendRes;
|
|
}
|
|
|
|
internal const httpd_uri_t api_devices_screen_image_uri = {
|
|
.uri = "/api/devices/screen.png",
|
|
.method = HTTP_GET,
|
|
.handler = api_devices_screen_image_handler,
|
|
.user_ctx = NULL};
|