Implement UI scaling and more (#501)
**New Features** * Runtime font accessors and new symbol fonts for text, launcher, statusbar, and shared icons. * Added font height base setting to device.properties * Text fonts now have 3 sizes: small, default, large **Improvements** * Renamed `UiScale` to `UiDensity` * Statusbar, toolbar and many UI components now compute heights and spacing from fonts/density. * SSD1306 initialization sequence refined for more stable startup. * Multiple image assets replaced by symbol-font rendering. * Many layout improvements related to density, font scaling and icon scaling * Updated folder name capitalization for newer style
This commit is contained in:
Ken Van Hoeylandt
committed by
GitHub
GitHub
parent
72c9b2b113
commit
9a11e6f47b
@@ -0,0 +1,278 @@
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
#include <tactility/concurrent/thread.h>
|
||||
#include <tactility/concurrent/mutex.h>
|
||||
#include <tactility/check.h>
|
||||
#include <tactility/delay.h>
|
||||
#include <tactility/log.h>
|
||||
#include <tactility/time.h>
|
||||
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <string>
|
||||
|
||||
static const size_t LOCAL_STORAGE_SELF_POINTER_INDEX = 0;
|
||||
static const char* TAG = "Thread";
|
||||
|
||||
struct Thread {
|
||||
TaskHandle_t taskHandle = nullptr;
|
||||
ThreadState state = THREAD_STATE_STOPPED;
|
||||
thread_main_fn_t mainFunction = nullptr;
|
||||
void* mainFunctionContext = nullptr;
|
||||
int32_t callbackResult = 0;
|
||||
thread_state_callback_t stateCallback = nullptr;
|
||||
void* stateCallbackContext = nullptr;
|
||||
std::string name = "unnamed";
|
||||
enum ThreadPriority priority = THREAD_PRIORITY_NORMAL;
|
||||
struct Mutex mutex = { 0 };
|
||||
configSTACK_DEPTH_TYPE stackSize = 4096;
|
||||
portBASE_TYPE affinity = -1;
|
||||
|
||||
Thread() {
|
||||
mutex_construct(&mutex);
|
||||
}
|
||||
|
||||
~Thread() {
|
||||
mutex_destruct(&mutex);
|
||||
}
|
||||
|
||||
void lock() { mutex_lock(&mutex); }
|
||||
|
||||
void unlock() { mutex_unlock(&mutex); }
|
||||
};
|
||||
|
||||
static void thread_set_state_internal(Thread* thread, ThreadState newState) {
|
||||
thread->lock();
|
||||
thread->state = newState;
|
||||
auto cb = thread->stateCallback;
|
||||
auto cb_ctx = thread->stateCallbackContext;
|
||||
thread->unlock();
|
||||
if (cb) {
|
||||
cb(newState, cb_ctx);
|
||||
}
|
||||
}
|
||||
|
||||
static void thread_main_body(void* context) {
|
||||
check(context != nullptr);
|
||||
auto* thread = static_cast<Thread*>(context);
|
||||
|
||||
// Save Thread instance pointer to task local storage
|
||||
check(pvTaskGetThreadLocalStoragePointer(nullptr, LOCAL_STORAGE_SELF_POINTER_INDEX) == nullptr);
|
||||
vTaskSetThreadLocalStoragePointer(nullptr, LOCAL_STORAGE_SELF_POINTER_INDEX, thread);
|
||||
|
||||
LOG_I(TAG, "Starting %s", thread->name.c_str()); // No need to lock as we don't allow mutation after thread start
|
||||
check(thread->state == THREAD_STATE_STARTING);
|
||||
thread_set_state_internal(thread, THREAD_STATE_RUNNING);
|
||||
|
||||
int32_t result = thread->mainFunction(thread->mainFunctionContext);
|
||||
thread->lock();
|
||||
thread->callbackResult = result;
|
||||
thread->unlock();
|
||||
|
||||
check(thread->state == THREAD_STATE_RUNNING);
|
||||
thread_set_state_internal(thread, THREAD_STATE_STOPPED);
|
||||
LOG_I(TAG, "Stopped %s", thread->name.c_str()); // No need to lock as we don't allow mutation after thread start
|
||||
|
||||
vTaskSetThreadLocalStoragePointer(nullptr, LOCAL_STORAGE_SELF_POINTER_INDEX, nullptr);
|
||||
|
||||
thread->lock();
|
||||
thread->taskHandle = nullptr;
|
||||
thread->unlock();
|
||||
|
||||
vTaskDelete(nullptr);
|
||||
}
|
||||
|
||||
extern "C" {
|
||||
|
||||
Thread* thread_alloc(void) {
|
||||
auto* thread = new(std::nothrow) Thread();
|
||||
if (thread == nullptr) {
|
||||
return nullptr;
|
||||
}
|
||||
return thread;
|
||||
}
|
||||
|
||||
Thread* thread_alloc_full(
|
||||
const char* name,
|
||||
configSTACK_DEPTH_TYPE stack_size,
|
||||
thread_main_fn_t function,
|
||||
void* function_context,
|
||||
portBASE_TYPE affinity
|
||||
) {
|
||||
auto* thread = new(std::nothrow) Thread();
|
||||
if (thread != nullptr) {
|
||||
thread_set_name(thread, name);
|
||||
thread_set_stack_size(thread, stack_size);
|
||||
thread_set_main_function(thread, function, function_context);
|
||||
thread_set_affinity(thread, affinity);
|
||||
}
|
||||
return thread;
|
||||
}
|
||||
|
||||
void thread_free(Thread* thread) {
|
||||
check(thread);
|
||||
check(thread->state == THREAD_STATE_STOPPED);
|
||||
check(thread->taskHandle == nullptr);
|
||||
delete thread;
|
||||
}
|
||||
|
||||
void thread_set_name(Thread* thread, const char* name) {
|
||||
check(name != nullptr);
|
||||
thread->lock();
|
||||
check(thread->state == THREAD_STATE_STOPPED);
|
||||
thread->name = name;
|
||||
thread->unlock();
|
||||
}
|
||||
|
||||
void thread_set_stack_size(Thread* thread, size_t stack_size) {
|
||||
thread->lock();
|
||||
check(stack_size > 0);
|
||||
check(thread->state == THREAD_STATE_STOPPED);
|
||||
thread->stackSize = stack_size;
|
||||
thread->unlock();
|
||||
}
|
||||
|
||||
void thread_set_affinity(Thread* thread, portBASE_TYPE affinity) {
|
||||
thread->lock();
|
||||
check(thread->state == THREAD_STATE_STOPPED);
|
||||
thread->affinity = affinity;
|
||||
thread->unlock();
|
||||
}
|
||||
|
||||
void thread_set_main_function(Thread* thread, thread_main_fn_t function, void* context) {
|
||||
thread->lock();
|
||||
check(function != nullptr);
|
||||
check(thread->state == THREAD_STATE_STOPPED);
|
||||
thread->mainFunction = function;
|
||||
thread->mainFunctionContext = context;
|
||||
thread->unlock();
|
||||
}
|
||||
|
||||
void thread_set_priority(Thread* thread, enum ThreadPriority priority) {
|
||||
thread->lock();
|
||||
check(thread->state == THREAD_STATE_STOPPED);
|
||||
thread->priority = priority;
|
||||
thread->unlock();
|
||||
}
|
||||
|
||||
void thread_set_state_callback(Thread* thread, thread_state_callback_t callback, void* context) {
|
||||
thread->lock();
|
||||
check(callback != nullptr);
|
||||
check(thread->state == THREAD_STATE_STOPPED);
|
||||
thread->stateCallback = callback;
|
||||
thread->stateCallbackContext = context;
|
||||
thread->unlock();
|
||||
}
|
||||
|
||||
ThreadState thread_get_state(Thread* thread) {
|
||||
check(xPortInIsrContext() == pdFALSE);
|
||||
thread->lock();
|
||||
ThreadState state = thread->state;
|
||||
thread->unlock();
|
||||
return state;
|
||||
}
|
||||
|
||||
error_t thread_start(Thread* thread) {
|
||||
thread->lock();
|
||||
check(thread->mainFunction != nullptr);
|
||||
check(thread->state == THREAD_STATE_STOPPED);
|
||||
check(thread->stackSize);
|
||||
thread->unlock();
|
||||
|
||||
thread_set_state_internal(thread, THREAD_STATE_STARTING);
|
||||
|
||||
thread->lock();
|
||||
uint32_t stack_depth = thread->stackSize / sizeof(StackType_t);
|
||||
enum ThreadPriority priority = thread->priority;
|
||||
portBASE_TYPE affinity = thread->affinity;
|
||||
thread->unlock();
|
||||
|
||||
BaseType_t result;
|
||||
if (affinity != -1) {
|
||||
#ifdef ESP_PLATFORM
|
||||
result = xTaskCreatePinnedToCore(
|
||||
thread_main_body,
|
||||
thread->name.c_str(),
|
||||
stack_depth,
|
||||
thread,
|
||||
(UBaseType_t)priority,
|
||||
&thread->taskHandle,
|
||||
affinity
|
||||
);
|
||||
#else
|
||||
result = xTaskCreate(
|
||||
thread_main_body,
|
||||
thread->name.c_str(),
|
||||
stack_depth,
|
||||
thread,
|
||||
(UBaseType_t)priority,
|
||||
&thread->taskHandle
|
||||
);
|
||||
#endif
|
||||
} else {
|
||||
result = xTaskCreate(
|
||||
thread_main_body,
|
||||
thread->name.c_str(),
|
||||
stack_depth,
|
||||
thread,
|
||||
(UBaseType_t)priority,
|
||||
&thread->taskHandle
|
||||
);
|
||||
}
|
||||
|
||||
if (result != pdPASS) {
|
||||
thread_set_state_internal(thread, THREAD_STATE_STOPPED);
|
||||
thread->lock();
|
||||
thread->taskHandle = nullptr;
|
||||
thread->unlock();
|
||||
return ERROR_UNDEFINED;
|
||||
}
|
||||
|
||||
return ERROR_NONE;
|
||||
}
|
||||
|
||||
error_t thread_join(Thread* thread, TickType_t timeout, TickType_t poll_interval) {
|
||||
check(thread_get_current() != thread);
|
||||
|
||||
TickType_t start_ticks = get_ticks();
|
||||
while (thread_get_task_handle(thread)) {
|
||||
delay_ticks(poll_interval);
|
||||
if (get_ticks() - start_ticks > timeout) {
|
||||
return ERROR_TIMEOUT;
|
||||
}
|
||||
}
|
||||
|
||||
return ERROR_NONE;
|
||||
}
|
||||
|
||||
TaskHandle_t thread_get_task_handle(Thread* thread) {
|
||||
thread->lock();
|
||||
auto* handle = thread->taskHandle;
|
||||
thread->unlock();
|
||||
return handle;
|
||||
}
|
||||
|
||||
int32_t thread_get_return_code(Thread* thread) {
|
||||
thread->lock();
|
||||
check(thread->state == THREAD_STATE_STOPPED);
|
||||
auto result = thread->callbackResult;
|
||||
thread->unlock();
|
||||
return result;
|
||||
}
|
||||
|
||||
uint32_t thread_get_stack_space(Thread* thread) {
|
||||
if (xPortInIsrContext() == pdTRUE) {
|
||||
return 0;
|
||||
}
|
||||
thread->lock();
|
||||
check(thread->state == THREAD_STATE_RUNNING);
|
||||
auto result = uxTaskGetStackHighWaterMark(thread->taskHandle) * sizeof(StackType_t);
|
||||
thread->unlock();
|
||||
return result;
|
||||
}
|
||||
|
||||
Thread* thread_get_current(void) {
|
||||
check(xPortInIsrContext() == pdFALSE);
|
||||
return (Thread*)pvTaskGetThreadLocalStoragePointer(nullptr, LOCAL_STORAGE_SELF_POINTER_INDEX);
|
||||
}
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user