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

Merge develop into main (#339)

Browse Source 
- Update ILI9341 driver to v2.0.1
- Lots of code cleanup for apps
- Refactor app "type" into "category" and added flags to the manifest (for show/hide statusbar and for hidden apps)
- Rename some ElfApp-related functionality and improved the way the static data was managed
- Rename "filebrowser" to "files"
- Added cstring functions to tt_init.cpp
- Minor fix in Boot app
- Updated external apps for SDK changes
This commit is contained in:
Ken Van Hoeylandt
2025-09-17 23:42:49 +02:00
committed by GitHub
parent a2af95b92d
commit faab6d825f
82 changed files with 349 additions and 360 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Tactility/Include/Tactility/app/App.h
+6 -6
View File
@@ -64,14 +64,14 @@ public:
auto lock = getMutex().asScopedLock();
lock.lock();
if (resultHolder != nullptr) {
outResult = resultHolder->result;
outBundle = std::move(resultHolder->resultData);
resultHolder = nullptr;
return true;
} else {
if (resultHolder == nullptr) {
return false;
}
outResult = resultHolder->result;
outBundle = std::move(resultHolder->resultData);
resultHolder = nullptr;
return true;
}
};
Tactility/Include/Tactility/app/AppContext.h
+1 -1
View File
@@ -13,7 +13,7 @@ enum class Result;
typedef union {
struct {
bool showStatusbar : 1;
bool hideStatusbar : 1;
};
unsigned char flags;
} Flags;
Tactility/Include/Tactility/app/AppManifest.h
+16 -10
View File
@@ -1,6 +1,6 @@
#pragma once
#include "Tactility/app/AppRegistration.h"
#include <Tactility/app/AppRegistration.h>
#include <string>
@@ -10,13 +10,7 @@ class App;
class AppContext;
/** Application types */
enum class Type {
/** Boot screen, shown before desktop is launched. */
Boot,
/** A launcher app sits at the root of the app stack after the boot splash is finished */
Launcher,
/** Apps that generally aren't started from the desktop (e.g. image viewer) */
Hidden,
enum class Category {
/** Standard apps, provided by the system. */
System,
/** The apps that are launched/shown by the Settings app. The Settings app itself is of type AppTypeSystem. */
@@ -60,6 +54,15 @@ public:
typedef std::shared_ptr<App>(*CreateApp)();
struct AppManifest {
struct Flags {
constexpr static uint32_t None = 0;
/** Don't show the statusbar */
constexpr static uint32_t HideStatusBar = 1 << 0;
/** Hint to other systems to not show this app (e.g. in launcher or settings) */
constexpr static uint32_t Hidden = 1 << 1;
};
/** The identifier by which the app is launched by the system and other apps. */
std::string id = {};
@@ -69,12 +72,15 @@ struct AppManifest {
/** Optional icon. */
std::string icon = {};
/** App type affects launch behaviour. */
Type type = Type::User;
/** App category helps with listing apps in Launcher, app list or settings apps. */
Category category = Category::User;
/** Where the app is located */
Location location = Location::internal();
/** Controls various settings */
uint32_t flags = Flags::None;
/** Create the instance of the app */
CreateApp createApp = nullptr;
};
Tactility/Include/Tactility/app/ElfApp.h
+1 -3
View File
@@ -14,9 +14,7 @@ typedef void (*OnShow)(void* appContext, void* _Nullable data, lv_obj_t* parent)
typedef void (*OnHide)(void* appContext, void* _Nullable data);
typedef void (*OnResult)(void* appContext, void* _Nullable data, LaunchId launchId, Result result, Bundle* resultData);
void setElfAppManifest(
const char* name,
const char* _Nullable icon,
void setElfAppParameters(
CreateData _Nullable createData,
DestroyData _Nullable destroyData,
OnCreate _Nullable onCreate,
Tactility/Include/Tactility/app/addgps/AddGps.h
-1
View File
@@ -1 +0,0 @@
#pragma once
Tactility/Include/Tactility/app/alertdialog/AlertDialog.h
+22 -21
View File
@@ -14,27 +14,28 @@
*/
namespace tt::app::alertdialog {
/**
* Show a dialog with the provided title, message and 0, 1 or more buttons.
* @param[in] title the title to show in the toolbar
* @param[in] message the message to display
* @param[in] buttonLabels the buttons to show
* @return the launch id
*/
LaunchId start(const std::string& title, const std::string& message, const std::vector<std::string>& buttonLabels);
/**
* Show a dialog with the provided title, message and 0, 1 or more buttons.
* @param[in] title the title to show in the toolbar
* @param[in] message the message to display
* @param[in] buttonLabels the buttons to show
* @return the launch id
*/
LaunchId start(const std::string& title, const std::string& message, const std::vector<std::string>& buttonLabels);
/**
* Show a dialog with the provided title, message and an OK button
* @param[in] title the title to show in the toolbar
* @param[in] message the message to display
* @return the launch id
*/
LaunchId start(const std::string& title, const std::string& message);
/**
* Show a dialog with the provided title, message and an OK button
* @param[in] title the title to show in the toolbar
* @param[in] message the message to display
* @return the launch id
*/
LaunchId start(const std::string& title, const std::string& message);
/**
* Get the index of the button that the user selected.
*
* @return a value greater than 0 when a selection was done, or -1 when the app was closed clicking one of the selection buttons.
*/
int32_t getResultIndex(const Bundle& bundle);
/**
* Get the index of the button that the user selected.
*
* @return a value greater than 0 when a selection was done, or -1 when the app was closed clicking one of the selection buttons.
*/
int32_t getResultIndex(const Bundle& bundle);
}
Tactility/Include/Tactility/app/filebrowser/FileBrowser.h
+1 -1
View File
@@ -1,6 +1,6 @@
#pragma once
namespace tt::app::filebrowser {
namespace tt::app::files {
void start();
Tactility/Include/Tactility/app/inputdialog/InputDialog.h
-1
View File
@@ -3,7 +3,6 @@
#include <Tactility/Bundle.h>
#include <string>
#include <vector>
/**
* Start the app by its ID and provide:
Tactility/Include/Tactility/app/selectiondialog/SelectionDialog.h
+8 -7
View File
@@ -15,12 +15,13 @@
*/
namespace tt::app::selectiondialog {
void start(const std::string& title, const std::vector<std::string>& items);
void start(const std::string& title, const std::vector<std::string>& items);
/**
* Get the index of the item that the user selected.
*
* @return a value greater than 0 when a selection was done, or -1 when the app was closed without selecting an item.
*/
int32_t getResultIndex(const Bundle& bundle);
/**
* Get the index of the item that the user selected.
*
* @return a value greater than 0 when a selection was done, or -1 when the app was closed without selecting an item.
*/
int32_t getResultIndex(const Bundle& bundle);
}
Tactility/Include/Tactility/app/serialconsole/ConnectView.h
-142
View File
@@ -1,142 +0,0 @@
#pragma once
#include "./View.h"
#include "Tactility/Preferences.h"
#include "Tactility/Tactility.h"
#include "Tactility/app/alertdialog/AlertDialog.h"
#include "Tactility/hal/uart/Uart.h"
#include "Tactility/lvgl/LvglSync.h"
#include "Tactility/lvgl/Style.h"
#include <Tactility/StringUtils.h>
#include <string>
namespace tt::app::serialconsole {
class ConnectView final : public View {
public:
typedef std::function<void(std::unique_ptr<hal::uart::Uart>)> OnConnectedFunction;
std::vector<std::string> uartNames;
Preferences preferences = Preferences("SerialConsole");
private:
OnConnectedFunction onConnected;
lv_obj_t* busDropdown = nullptr;
lv_obj_t* speedTextarea = nullptr;
int32_t getSpeedInput() const {
auto* speed_text = lv_textarea_get_text(speedTextarea);
return std::stoi(speed_text);
}
void onConnect() {
auto lock = lvgl::getSyncLock()->asScopedLock();
if (!lock.lock(lvgl::defaultLockTime)) {
return;
}
auto selected_uart_index = lv_dropdown_get_selected(busDropdown);
if (selected_uart_index >= uartNames.size()) {
alertdialog::start("Error", "No UART selected");
return;
}
auto uart_name = uartNames[selected_uart_index];
auto uart = hal::uart::open(uart_name);
if (uart == nullptr) {
alertdialog::start("Error", "Failed to connect to UART");
return;
}
int speed = getSpeedInput();
if (speed <= 0) {
alertdialog::start("Error", "Invalid speed");
return;
}
if (!uart->start()) {
alertdialog::start("Error", "Failed to initialize");
return;
}
if (!uart->setBaudRate(speed)) {
uart->stop();
alertdialog::start("Error", "Failed to set baud rate");
return;
}
onConnected(std::move(uart));
}
static void onConnectCallback(lv_event_t* event) {
auto* view = (ConnectView*)lv_event_get_user_data(event);
view->onConnect();
}
public:
explicit ConnectView(OnConnectedFunction onConnected) : onConnected(std::move(onConnected)) {}
void onStart(lv_obj_t* parent) {
uartNames = hal::uart::getNames();
auto* wrapper = lv_obj_create(parent);
lv_obj_set_size(wrapper, LV_PCT(100), LV_PCT(100));
lv_obj_set_style_pad_ver(wrapper, 0, 0);
lv_obj_set_style_border_width(wrapper, 0, 0);
lvgl::obj_set_style_bg_invisible(wrapper);
busDropdown = lv_dropdown_create(wrapper);
auto bus_options = string::join(uartNames, "\n");
lv_dropdown_set_options(busDropdown, bus_options.c_str());
lv_obj_align(busDropdown, LV_ALIGN_TOP_RIGHT, 0, 0);
lv_obj_set_width(busDropdown, LV_PCT(50));
lv_obj_set_style_border_color(busDropdown, lv_color_hex(0xFAFAFA), LV_PART_MAIN);
lv_obj_set_style_border_width(busDropdown, 1, LV_PART_MAIN);
int32_t bus_index = 0;
preferences.optInt32("bus", bus_index);
if (bus_index < uartNames.size()) {
lv_dropdown_set_selected(busDropdown, bus_index);
}
auto* bus_label = lv_label_create(wrapper);
lv_obj_align(bus_label, LV_ALIGN_TOP_LEFT, 0, 10);
lv_label_set_text(bus_label, "Bus");
int32_t speed = 115200;
preferences.optInt32("speed", speed);
speedTextarea = lv_textarea_create(wrapper);
lv_textarea_set_text(speedTextarea, std::to_string(speed).c_str());
lv_textarea_set_one_line(speedTextarea, true);
lv_obj_set_width(speedTextarea, LV_PCT(50));
lv_obj_align(speedTextarea, LV_ALIGN_TOP_RIGHT, 0, 40);
auto* baud_rate_label = lv_label_create(wrapper);
lv_obj_align(baud_rate_label, LV_ALIGN_TOP_LEFT, 0, 50);
lv_label_set_text(baud_rate_label, "Baud");
auto* connect_button = lv_button_create(wrapper);
auto* connect_label = lv_label_create(connect_button);
lv_label_set_text(connect_label, "Connect");
lv_obj_align(connect_button, LV_ALIGN_TOP_MID, 0, 90);
lv_obj_add_event_cb(connect_button, onConnectCallback, LV_EVENT_SHORT_CLICKED, this);
}
void onStop() {
int speed = getSpeedInput();
if (speed > 0) {
preferences.putInt32("speed", speed);
}
auto bus_index = (int32_t)lv_dropdown_get_selected(busDropdown);
preferences.putInt32("bus", bus_index);
}
};
} // namespace tt::app::serialconsole
Tactility/Include/Tactility/app/serialconsole/ConsoleView.h
-286
View File
@@ -1,286 +0,0 @@
#pragma once
#include "./View.h"
#include "Tactility/Timer.h"
#include <cstring>
#include <sstream>
#define TAG "SerialConsole"
namespace tt::app::serialconsole {
constexpr size_t receiveBufferSize = 512;
constexpr size_t renderBufferSize = receiveBufferSize + 2; // Leave space for newline at split and null terminator at the end
class ConsoleView final : public View {
private:
lv_obj_t* _Nullable parent = nullptr;
lv_obj_t* _Nullable logTextarea = nullptr;
lv_obj_t* _Nullable inputTextarea = nullptr;
std::unique_ptr<hal::uart::Uart> _Nullable uart = nullptr;
std::shared_ptr<Thread> uartThread _Nullable = nullptr;
bool uartThreadInterrupted = false;
std::shared_ptr<Thread> viewThread _Nullable = nullptr;
bool viewThreadInterrupted = false;
Mutex mutex = Mutex(Mutex::Type::Recursive);
uint8_t receiveBuffer[receiveBufferSize];
uint8_t renderBuffer[renderBufferSize];
size_t receiveBufferPosition = 0;
std::string terminatorString = "\n";
bool isUartThreadInterrupted() const {
auto lock = mutex.asScopedLock();
lock.lock();
return uartThreadInterrupted;
}
bool isViewThreadInterrupted() const {
auto lock = mutex.asScopedLock();
lock.lock();
return viewThreadInterrupted;
}
void updateViews() {
auto lvgl_lock = lvgl::getSyncLock()->asScopedLock();
if (!lvgl_lock.lock(lvgl::defaultLockTime)) {
return;
}
if (parent == nullptr) {
return;
}
// Updating the view is expensive, so we only want to set the text once:
// Gather all the lines in a single buffer
if (mutex.lock()) {
size_t first_part_size = receiveBufferSize - receiveBufferPosition;
memcpy(renderBuffer, receiveBuffer + receiveBufferPosition, first_part_size);
renderBuffer[receiveBufferPosition] = '\n';
if (receiveBufferPosition > 0) {
memcpy(renderBuffer + first_part_size + 1, receiveBuffer, (receiveBufferSize - first_part_size));
renderBuffer[receiveBufferSize - 1] = 0x00;
}
mutex.unlock();
}
if (lvgl::lock(lvgl::defaultLockTime)) {
lv_textarea_set_text(logTextarea, (const char*)renderBuffer);
lvgl::unlock();
}
}
int32_t viewThreadMain() {
while (!isViewThreadInterrupted()) {
auto start_time = kernel::getTicks();
updateViews();
auto end_time = kernel::getTicks();
auto time_diff = end_time - start_time;
if (time_diff < 500U) {
kernel::delayTicks((500U - time_diff) / portTICK_PERIOD_MS);
}
}
return 0;
}
int32_t uartThreadMain() {
uint8_t byte;
while (!isUartThreadInterrupted()) {
assert(uart != nullptr);
bool success = uart->readByte(&byte, 50 / portTICK_PERIOD_MS);
// Thread might've been interrupted in the meanwhile
if (isUartThreadInterrupted()) {
break;
}
if (success) {
mutex.lock();
receiveBuffer[receiveBufferPosition++] = byte;
if (receiveBufferPosition == receiveBufferSize) {
receiveBufferPosition = 0;
}
mutex.unlock();
}
}
return 0;
}
static void onSendClickedCallback(lv_event_t* event) {
auto* view = (ConsoleView*)lv_event_get_user_data(event);
view->onSendClicked();
}
static void onTerminatorDropdownValueChangedCallback(lv_event_t* event) {
auto* view = (ConsoleView*)lv_event_get_user_data(event);
view->onTerminatorDropDownValueChanged(event);
}
void onTerminatorDropDownValueChanged(lv_event_t* event) {
auto* dropdown = static_cast<lv_obj_t*>(lv_event_get_target(event));
mutex.lock();
switch (lv_dropdown_get_selected(dropdown)) {
case 0:
terminatorString = "\n";
break;
case 1:
terminatorString = "\r\n";
break;
}
mutex.unlock();
}
void onSendClicked() {
mutex.lock();
std::string input_text = lv_textarea_get_text(inputTextarea);
std::string to_send = input_text + terminatorString;
mutex.unlock();
auto* safe_uart = uart.get();
if (safe_uart != nullptr) {
if (!safe_uart->writeString(to_send.c_str(), 100 / portTICK_PERIOD_MS)) {
TT_LOG_E(TAG, "Failed to send \"%s\"", input_text.c_str());
}
}
lv_textarea_set_text(inputTextarea, "");
}
public:
void startLogic(std::unique_ptr<hal::uart::Uart> newUart) {
memset(receiveBuffer, 0, receiveBufferSize);
assert(uartThread == nullptr);
assert(uart == nullptr);
uart = std::move(newUart);
uartThreadInterrupted = false;
uartThread = std::make_unique<Thread>(
"SerConsUart",
4096,
[this]() {
return this->uartThreadMain();
}
);
uartThread->setPriority(tt::Thread::Priority::High);
uartThread->start();
}
void startViews(lv_obj_t* parent) {
this->parent = parent;
lv_obj_set_style_pad_gap(parent, 2, 0);
logTextarea = lv_textarea_create(parent);
lv_textarea_set_placeholder_text(logTextarea, "Waiting for data...");
lv_obj_set_flex_grow(logTextarea, 1);
lv_obj_set_width(logTextarea, LV_PCT(100));
lv_obj_add_state(logTextarea, LV_STATE_DISABLED);
lv_obj_set_style_margin_ver(logTextarea, 0, 0);
auto* input_wrapper = lv_obj_create(parent);
lv_obj_set_size(input_wrapper, LV_PCT(100), LV_SIZE_CONTENT);
lv_obj_set_style_pad_all(input_wrapper, 0, 0);
lv_obj_set_style_border_width(input_wrapper, 0, 0);
lv_obj_set_width(input_wrapper, LV_PCT(100));
lv_obj_set_flex_flow(input_wrapper, LV_FLEX_FLOW_ROW);
inputTextarea = lv_textarea_create(input_wrapper);
lv_textarea_set_one_line(inputTextarea, true);
lv_textarea_set_placeholder_text(inputTextarea, "Text to send");
lv_obj_set_width(inputTextarea, LV_PCT(100));
lv_obj_set_flex_grow(inputTextarea, 1);
auto* terminator_dropdown = lv_dropdown_create(input_wrapper);
lv_dropdown_set_options(terminator_dropdown, "\\n\n\\r\\n");
lv_obj_set_width(terminator_dropdown, 70);
lv_obj_add_event_cb(terminator_dropdown, onTerminatorDropdownValueChangedCallback, LV_EVENT_VALUE_CHANGED, this);
auto* button = lv_button_create(input_wrapper);
auto* button_label = lv_label_create(button);
lv_label_set_text(button_label, "Send");
lv_obj_add_event_cb(button, onSendClickedCallback, LV_EVENT_SHORT_CLICKED, this);
viewThreadInterrupted = false;
viewThread = std::make_unique<Thread>(
"SerConsView",
4096,
[this]() {
return this->viewThreadMain();
}
);
viewThread->setPriority(THREAD_PRIORITY_RENDER);
viewThread->start();
}
void stopLogic() {
auto lock = mutex.asScopedLock();
lock.lock();
uartThreadInterrupted = true;
// Detach thread, it will auto-delete when leaving the current scope
auto old_uart_thread = std::move(uartThread);
// Unlock so thread can lock
lock.unlock();
if (old_uart_thread->getState() != Thread::State::Stopped) {
// Wait for thread to finish
old_uart_thread->join();
}
}
void stopViews() {
auto lock = mutex.asScopedLock();
lock.lock();
viewThreadInterrupted = true;
// Detach thread, it will auto-delete when leaving the current scope
auto old_view_thread = std::move(viewThread);
// Unlock so thread can lock
lock.unlock();
if (old_view_thread->getState() != Thread::State::Stopped) {
// Wait for thread to finish
old_view_thread->join();
}
}
void stopUart() {
auto lock = mutex.asScopedLock();
lock.lock();
if (uart != nullptr && uart->isStarted()) {
uart->stop();
uart = nullptr;
}
}
void onStart(lv_obj_t* parent, std::unique_ptr<hal::uart::Uart> newUart) {
auto lock = mutex.asScopedLock();
lock.lock();
startLogic(std::move(newUart));
startViews(parent);
}
void onStop() final {
stopViews();
stopLogic();
stopUart();
}
};
} // namespace tt::app::serialconsole
Tactility/Include/Tactility/app/serialconsole/View.h
-12
View File
@@ -1,12 +0,0 @@
#pragma once
#include <lvgl.h>
namespace tt::app::serialconsole {
class View {
public:
virtual void onStop() = 0;
};
}