Touch and display driver subsystems reworked (and more) (#302)

- Refactored `TouchDevice`: it can now start/stop LVGL separately, and it has an optional `TouchDriver` interface
- Refactored `DisplayDevice`: it can now start/stop LVGL separately, and it has an optional `DisplayDriver` interface
- Updated all boards and drivers for above changes
- LVGL can now be stopped and (re)started on the fly
- Fixed issues with restarting Gui and Statusbar services
- Refactored `Gui` service to be class and renamed `Gui` to `GuiService`
- Fixed `Statusbar` service: forgot to deregister one of the icons
- Updated `esp_lcd_st7701` to v1.1.3
- `lv_textarea_create()` now automatically registers the hardware keyboard hooks (by wrapping the function)
- Fixed and updated `tactility.py`
- Cleanup of a lot of code
- `BootInitLvglBegin` and `BootInitLvglEnd` are replaced by `LvglStarted` and `LvglStopped`.
- Introduced `tt::service::State` which is accessible via `tt::service::getState()` (and internally via `ServiceInstance`)
- Started replacing `#define TAG` with `constexpr auto TAG = "..";`

Drivers/EspLcdCompat/Source/EspLcdDisplay.cpp

@@ -0,0 +1,102 @@
+#include "EspLcdDisplay.h"
+#include "EspLcdDisplayDriver.h"
+
+#include <assert.h>
+#include <esp_lvgl_port_disp.h>
+#include <Tactility/Check.h>
+#include <Tactility/LogEsp.h>
+#include <Tactility/hal/touch/TouchDevice.h>
+
+constexpr const char* TAG = "EspLcdDispDrv";
+
+EspLcdDisplay::~EspLcdDisplay() {
+    if (displayDriver != nullptr && displayDriver.use_count() > 1) {
+        tt_crash("DisplayDriver is still in use. This will cause memory access violations.");
+    }
+}
+
+bool EspLcdDisplay::start() {
+    if (!createIoHandle(ioHandle)) {
+        TT_LOG_E(TAG, "Failed to create IO handle");
+        return false;
+    }
+
+    if (!createPanelHandle(ioHandle, panelHandle)) {
+        TT_LOG_E(TAG, "Failed to create panel handle");
+        esp_lcd_panel_io_del(ioHandle);
+        return false;
+    }
+
+    return true;
+}
+
+bool EspLcdDisplay::stop() {
+    if (lvglDisplay != nullptr) {
+        stopLvgl();
+        lvglDisplay = nullptr;
+    }
+
+    if (panelHandle != nullptr && esp_lcd_panel_del(panelHandle) != ESP_OK) {
+        return false;
+    }
+
+    if (ioHandle != nullptr && esp_lcd_panel_io_del(ioHandle) != ESP_OK) {
+        return false;
+    }
+
+    if (displayDriver != nullptr && displayDriver.use_count() > 1) {
+        TT_LOG_W(TAG, "DisplayDriver is still in use.");
+    }
+
+    return true;
+}
+
+bool EspLcdDisplay::startLvgl() {
+    assert(lvglDisplay == nullptr);
+
+    if (displayDriver != nullptr && displayDriver.use_count() > 1) {
+        TT_LOG_W(TAG, "DisplayDriver is still in use.");
+    }
+
+    lvglPortDisplayConfig = getLvglPortDisplayConfig(ioHandle, panelHandle);
+
+    if (isRgbPanel()) {
+        auto rgb_config = getLvglPortDisplayRgbConfig(ioHandle, panelHandle);
+        lvglDisplay = lvgl_port_add_disp_rgb(&lvglPortDisplayConfig, &rgb_config);
+    } else {
+        lvglDisplay = lvgl_port_add_disp(&lvglPortDisplayConfig);
+    }
+
+    auto touch_device = getTouchDevice();
+    if (touch_device != nullptr) {
+        touch_device->startLvgl(lvglDisplay);
+    }
+
+    return lvglDisplay != nullptr;
+}
+
+bool EspLcdDisplay::stopLvgl() {
+    if (lvglDisplay == nullptr) {
+        return false;
+    }
+
+    auto touch_device = getTouchDevice();
+    if (touch_device != nullptr) {
+        touch_device->stopLvgl();
+    }
+
+    lvgl_port_remove_disp(lvglDisplay);
+    lvglDisplay = nullptr;
+    return true;
+}
+
+std::shared_ptr<display::DisplayDriver> EspLcdDisplay::getDisplayDriver() {
+    assert(lvglDisplay == nullptr); // Still attached to LVGL context. Call stopLvgl() first.
+    if (displayDriver == nullptr) {
+        displayDriver = std::make_shared<EspLcdDisplayDriver>(
+            panelHandle,
+            lvglPortDisplayConfig
+        );
+    }
+    return displayDriver;
+}

Drivers/EspLcdCompat/Source/EspLcdDisplay.h

@@ -0,0 +1,60 @@
+#pragma once
+
+#include <Tactility/hal/display/DisplayDevice.h>
+
+#include <esp_lcd_types.h>
+#include <esp_lvgl_port_disp.h>
+#include <Tactility/Check.h>
+
+class EspLcdDisplay : tt::hal::display::DisplayDevice {
+
+    esp_lcd_panel_io_handle_t _Nullable ioHandle = nullptr;
+    esp_lcd_panel_handle_t _Nullable panelHandle = nullptr;
+    lv_display_t* _Nullable lvglDisplay = nullptr;
+    lvgl_port_display_cfg_t _Nullable lvglPortDisplayConfig;
+    std::shared_ptr<tt::hal::display::DisplayDriver> _Nullable displayDriver;
+
+protected:
+
+    // Used for sending commands such as setting curves
+    esp_lcd_panel_io_handle_t getIoHandle() const { return ioHandle; }
+
+    virtual bool createIoHandle(esp_lcd_panel_io_handle_t& outHandle) = 0;
+
+    virtual bool createPanelHandle(esp_lcd_panel_io_handle_t ioHandle, esp_lcd_panel_handle_t& panelHandle) = 0;
+
+    virtual lvgl_port_display_cfg_t getLvglPortDisplayConfig(esp_lcd_panel_io_handle_t ioHandle, esp_lcd_panel_handle_t panelHandle) = 0;
+
+    virtual bool isRgbPanel() const { return false; }
+
+    virtual lvgl_port_display_rgb_cfg_t getLvglPortDisplayRgbConfig(esp_lcd_panel_io_handle_t ioHandle, esp_lcd_panel_handle_t panelHandle) { tt_crash("Not supported"); }
+
+public:
+
+    ~EspLcdDisplay() override;
+
+    bool start() final;
+
+    bool stop() final;
+
+    // region LVGL
+
+    bool supportsLvgl() const final { return true; }
+
+    bool startLvgl() final;
+
+    bool stopLvgl() final;
+
+    lv_display_t* _Nullable getLvglDisplay() const final { return lvglDisplay; }
+
+    // endregion
+
+    // region NativeDisplay
+
+    bool supportsDisplayDriver() const override { return true; }
+
+    /** @return a NativeDisplay instance if this device supports it */
+    std::shared_ptr<tt::hal::display::DisplayDriver> _Nullable getDisplayDriver() final;
+
+    // endregion
+};

Drivers/EspLcdCompat/Source/EspLcdDisplayDriver.h

@@ -0,0 +1,44 @@
+#pragma once
+
+#include <Tactility/hal/display/DisplayDriver.h>
+#include <esp_lcd_panel_ops.h>
+#include <esp_lvgl_port_disp.h>
+
+using namespace tt::hal;
+
+class EspLcdDisplayDriver : public display::DisplayDriver {
+
+    esp_lcd_panel_handle_t panelHandle;
+    const lvgl_port_display_cfg_t& lvglPortDisplayConfig;
+
+public:
+
+    EspLcdDisplayDriver(
+        esp_lcd_panel_handle_t panelHandle,
+        const lvgl_port_display_cfg_t& lvglPortDisplayConfig
+    ) : panelHandle(panelHandle), lvglPortDisplayConfig(lvglPortDisplayConfig) {}
+
+    display::ColorFormat getColorFormat() const override {
+        using display::ColorFormat;
+        switch (lvglPortDisplayConfig.color_format) {
+            case LV_COLOR_FORMAT_I1:
+                return ColorFormat::Monochrome;
+            case LV_COLOR_FORMAT_RGB565:
+                // swap_bytes is only used for the 565 color format
+                // see lvgl_port_flush_callback() in esp_lvgl_port_disp.c
+                return lvglPortDisplayConfig.flags.swap_bytes ? ColorFormat::BGR565 : ColorFormat::RGB565;
+            case LV_COLOR_FORMAT_RGB888:
+                return ColorFormat::RGB888;
+            default:
+                return ColorFormat::RGB565;
+        }
+    }
+
+    bool drawBitmap(int xStart, int yStart, int xEnd, int yEnd, const void* pixelData) override {
+        return esp_lcd_panel_draw_bitmap(panelHandle, xStart, yStart, xEnd, yEnd, pixelData) == ESP_OK;
+    }
+
+    uint16_t getPixelWidth() const override { return lvglPortDisplayConfig.hres; }
+
+    uint16_t getPixelHeight() const override { return lvglPortDisplayConfig.vres; }
+};

Drivers/EspLcdCompat/Source/EspLcdTouch.cpp

@@ -0,0 +1,92 @@
+#include "EspLcdTouch.h"
+
+#include <EspLcdTouchDriver.h>
+#include <esp_lvgl_port_touch.h>
+#include <Tactility/LogEsp.h>
+
+constexpr const char* TAG = "EspLcdTouch";
+
+bool EspLcdTouch::start() {
+    if (!createIoHandle(ioHandle) != ESP_OK) {
+        TT_LOG_E(TAG, "Touch IO failed");
+        return false;
+    }
+
+    config = createEspLcdTouchConfig();
+
+    if (!createTouchHandle(ioHandle, config, touchHandle)) {
+        TT_LOG_E(TAG, "Driver init failed");
+        esp_lcd_panel_io_del(ioHandle);
+        ioHandle = nullptr;
+        return false;
+    }
+
+    return true;
+}
+
+bool EspLcdTouch::stop() {
+    if (lvglDevice != nullptr) {
+        stopLvgl();
+    }
+
+    if (ioHandle != nullptr) {
+        esp_lcd_panel_io_del(ioHandle);
+        ioHandle = nullptr;
+    }
+
+    if (touchHandle != nullptr) {
+        esp_lcd_touch_del(touchHandle);
+        touchHandle = nullptr;
+    }
+
+    return true;
+}
+
+bool EspLcdTouch::startLvgl(lv_disp_t* display) {
+    if (lvglDevice != nullptr) {
+        return false;
+    }
+
+    if (touchDriver != nullptr && touchDriver.use_count() > 1) {
+        TT_LOG_W(TAG, "TouchDriver is still in use.");
+    }
+
+    const lvgl_port_touch_cfg_t touch_cfg = {
+        .disp = display,
+        .handle = touchHandle,
+    };
+
+    TT_LOG_I(TAG, "Adding touch to LVGL");
+    lvglDevice = lvgl_port_add_touch(&touch_cfg);
+    if (lvglDevice == nullptr) {
+        TT_LOG_E(TAG, "Adding touch failed");
+        return false;
+    }
+
+    return true;
+}
+
+bool EspLcdTouch::stopLvgl() {
+    if (lvglDevice == nullptr) {
+        return false;
+    }
+
+    lvgl_port_remove_touch(lvglDevice);
+    lvglDevice = nullptr;
+
+    return true;
+}
+
+std::shared_ptr<tt::hal::touch::TouchDriver> _Nullable EspLcdTouch::getTouchDriver() {
+    assert(lvglDevice == nullptr); // Still attached to LVGL context. Call stopLvgl() first.
+
+    if (touchHandle == nullptr) {
+        return nullptr;
+    }
+
+    if (touchDriver == nullptr) {
+        touchDriver = std::make_shared<EspLcdTouchDriver>(touchHandle);
+    }
+
+    return touchDriver;
+}

Drivers/EspLcdCompat/Source/EspLcdTouch.h

@@ -0,0 +1,44 @@
+#pragma once
+
+#include <esp_lcd_touch.h>
+#include <esp_lcd_types.h>
+#include <lvgl.h>
+#include <Tactility/hal/touch/TouchDevice.h>
+#include <Tactility/hal/touch/TouchDriver.h>
+
+class EspLcdTouch : public tt::hal::touch::TouchDevice {
+
+    esp_lcd_touch_config_t config;
+    esp_lcd_panel_io_handle_t _Nullable ioHandle = nullptr;
+    esp_lcd_touch_handle_t _Nullable touchHandle = nullptr;
+    lv_indev_t* _Nullable lvglDevice = nullptr;
+    std::shared_ptr<tt::hal::touch::TouchDriver> touchDriver;
+
+protected:
+
+    esp_lcd_touch_handle_t _Nullable getTouchHandle() const { return touchHandle; }
+
+    virtual bool createIoHandle(esp_lcd_panel_io_handle_t& ioHandle) = 0;
+
+    virtual bool createTouchHandle(esp_lcd_panel_io_handle_t ioHandle, const esp_lcd_touch_config_t& configuration, esp_lcd_touch_handle_t& touchHandle) = 0;
+
+    virtual esp_lcd_touch_config_t createEspLcdTouchConfig() = 0;
+
+public:
+
+    bool start() final;
+
+    bool stop() final;
+
+    bool supportsLvgl() const final { return true; }
+
+    bool startLvgl(lv_display_t* display) final;
+
+    bool stopLvgl() final;
+
+    lv_indev_t* _Nullable getLvglIndev() final { return lvglDevice; }
+
+    bool supportsTouchDriver() override { return true; }
+
+    std::shared_ptr<tt::hal::touch::TouchDriver> _Nullable getTouchDriver() final;
+};

Drivers/EspLcdCompat/Source/EspLcdTouchDriver.cpp

@@ -0,0 +1,13 @@
+#include "EspLcdTouchDriver.h"
+
+#include <Tactility/LogEsp.h>
+
+constexpr const char* TAG = "EspLcdTouchDriver";
+
+bool EspLcdTouchDriver::getTouchedPoints(uint16_t* x, uint16_t* y, uint16_t* _Nullable strength, uint8_t* pointCount, uint8_t maxPointCount) {
+    if (esp_lcd_touch_read_data(handle) != ESP_OK) {
+        TT_LOG_E(TAG, "Read data failed");
+        return false;
+    }
+    return esp_lcd_touch_get_coordinates(handle, x, y, strength, pointCount, maxPointCount) == ESP_OK;
+}

Drivers/EspLcdCompat/Source/EspLcdTouchDriver.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <esp_lcd_touch.h>
+#include <Tactility/hal/touch/TouchDriver.h>
+
+class EspLcdTouchDriver final : public tt::hal::touch::TouchDriver {
+
+    esp_lcd_touch_handle_t handle;
+
+public:
+
+    EspLcdTouchDriver(esp_lcd_touch_handle_t handle) : handle(handle) {}
+
+    bool getTouchedPoints(uint16_t* x, uint16_t* y, uint16_t* strength, uint8_t* pointCount, uint8_t maxPointCount) override;
+};