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

TactilityKernel/source/drivers/gpio_controller.cpp

@@ -0,0 +1,142 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#include <tactility/driver.h>
+#include <tactility/drivers/gpio_controller.h>
+
+#include <tactility/concurrent/mutex.h>
+#include <tactility/drivers/gpio_descriptor.h>
+
+#include <cstdlib>
+#include <new>
+
+#define GPIO_INTERNAL_API(driver) ((struct GpioControllerApi*)(driver)->api)
+
+extern "C" {
+
+struct GpioControllerData {
+    struct Mutex mutex {};
+    uint32_t pin_count;
+    struct GpioDescriptor* descriptors = nullptr;
+
+    explicit GpioControllerData(uint32_t pin_count) : pin_count(pin_count) {
+        mutex_construct(&mutex);
+    }
+
+    error_t init_descriptors(Device* device, void* controller_context) {
+        descriptors = (struct GpioDescriptor*)calloc(pin_count, sizeof(struct GpioDescriptor));
+        if (!descriptors) return ERROR_OUT_OF_MEMORY;
+        for (uint32_t i = 0; i < pin_count; ++i) {
+            descriptors[i].controller = device;
+            descriptors[i].pin = (gpio_pin_t)i;
+            descriptors[i].owner_type = GPIO_OWNER_NONE;
+            descriptors[i].controller_context = controller_context;
+        }
+        return ERROR_NONE;
+    }
+
+    ~GpioControllerData() {
+        if (descriptors != nullptr) {
+            free(descriptors);
+        }
+        mutex_destruct(&mutex);
+    }
+};
+
+struct GpioDescriptor* gpio_descriptor_acquire(
+    struct Device* controller,
+    gpio_pin_t pin_number,
+    enum GpioOwnerType owner
+) {
+    check(owner != GPIO_OWNER_NONE);
+
+    auto* data = (struct GpioControllerData*)device_get_driver_data(controller);
+
+    mutex_lock(&data->mutex);
+    if (pin_number >= data->pin_count) {
+        mutex_unlock(&data->mutex);
+        return nullptr;
+    }
+
+    struct GpioDescriptor* desc = &data->descriptors[pin_number];
+    if (desc->owner_type != GPIO_OWNER_NONE) {
+        mutex_unlock(&data->mutex);
+        return nullptr;
+    }
+
+    desc->owner_type = owner;
+    mutex_unlock(&data->mutex);
+
+    return desc;
+}
+
+error_t gpio_descriptor_release(struct GpioDescriptor* descriptor) {
+    descriptor->owner_type = GPIO_OWNER_NONE;
+    return ERROR_NONE;
+}
+
+error_t gpio_controller_get_pin_count(struct Device* device, uint32_t* count) {
+    auto* data = (struct GpioControllerData*)device_get_driver_data(device);
+    *count = data->pin_count;
+    return ERROR_NONE;
+}
+
+error_t gpio_controller_init_descriptors(struct Device* device, uint32_t pin_count, void* controller_context) {
+    auto* data = new(std::nothrow) GpioControllerData(pin_count);
+    if (!data) return ERROR_OUT_OF_MEMORY;
+
+    if (data->init_descriptors(device, controller_context) != ERROR_NONE) {
+        delete data;
+        return ERROR_OUT_OF_MEMORY;
+    }
+
+    device_set_driver_data(device, data);
+    return ERROR_NONE;
+}
+
+error_t gpio_controller_deinit_descriptors(struct Device* device) {
+    auto* data = static_cast<struct GpioControllerData*>(device_get_driver_data(device));
+    delete data;
+    device_set_driver_data(device, nullptr);
+    return ERROR_NONE;
+}
+
+error_t gpio_descriptor_set_level(struct GpioDescriptor* descriptor, bool high) {
+    const auto* driver = device_get_driver(descriptor->controller);
+    return GPIO_INTERNAL_API(driver)->set_level(descriptor, high);
+}
+
+error_t gpio_descriptor_get_level(struct GpioDescriptor* descriptor, bool* high) {
+    const auto* driver = device_get_driver(descriptor->controller);
+    return GPIO_INTERNAL_API(driver)->get_level(descriptor, high);
+}
+
+error_t gpio_descriptor_set_flags(struct GpioDescriptor* descriptor, gpio_flags_t flags) {
+    const auto* driver = device_get_driver(descriptor->controller);
+    return GPIO_INTERNAL_API(driver)->set_flags(descriptor, flags);
+}
+
+error_t gpio_descriptor_get_flags(struct GpioDescriptor* descriptor, gpio_flags_t* flags) {
+    const auto* driver = device_get_driver(descriptor->controller);
+    return GPIO_INTERNAL_API(driver)->get_flags(descriptor, flags);
+}
+
+error_t gpio_descriptor_get_pin_number(struct GpioDescriptor* descriptor, gpio_pin_t* pin) {
+    *pin = descriptor->pin;
+    return ERROR_NONE;
+}
+
+error_t gpio_descriptor_get_native_pin_number(struct GpioDescriptor* descriptor, void* pin_number) {
+    const auto* driver = device_get_driver(descriptor->controller);
+    return GPIO_INTERNAL_API(driver)->get_native_pin_number(descriptor, pin_number);
+}
+
+error_t gpio_descriptor_get_owner_type(struct GpioDescriptor* descriptor, GpioOwnerType* owner_type) {
+    *owner_type = descriptor->owner_type;
+    return ERROR_NONE;
+}
+
+const struct DeviceType GPIO_CONTROLLER_TYPE {
+    .name = "gpio-controller"
+};
+
+}

TactilityKernel/source/drivers/i2c_controller.cpp

@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: Apache-2.0
+#include <tactility/drivers/i2c_controller.h>
+#include <tactility/error.h>
+
+#define I2C_DRIVER_API(driver) ((struct I2cControllerApi*)driver->api)
+
+extern "C" {
+
+error_t i2c_controller_read(Device* device, uint8_t address, uint8_t* data, size_t dataSize, TickType_t timeout) {
+    const auto* driver = device_get_driver(device);
+    return I2C_DRIVER_API(driver)->read(device, address, data, dataSize, timeout);
+}
+
+error_t i2c_controller_write(Device* device, uint8_t address, const uint8_t* data, uint16_t dataSize, TickType_t timeout) {
+    const auto* driver = device_get_driver(device);
+    return I2C_DRIVER_API(driver)->write(device, address, data, dataSize, timeout);
+}
+
+error_t i2c_controller_write_read(Device* device, uint8_t address, const uint8_t* writeData, size_t writeDataSize, uint8_t* readData, size_t readDataSize, TickType_t timeout) {
+    const auto* driver = device_get_driver(device);
+    return I2C_DRIVER_API(driver)->write_read(device, address, writeData, writeDataSize, readData, readDataSize, timeout);
+}
+
+error_t i2c_controller_read_register(Device* device, uint8_t address, uint8_t reg, uint8_t* data, size_t dataSize, TickType_t timeout) {
+    const auto* driver = device_get_driver(device);
+    return I2C_DRIVER_API(driver)->read_register(device, address, reg, data, dataSize, timeout);
+}
+
+error_t i2c_controller_write_register(Device* device, uint8_t address, uint8_t reg, const uint8_t* data, uint16_t dataSize, TickType_t timeout) {
+    const auto* driver = device_get_driver(device);
+    return I2C_DRIVER_API(driver)->write_register(device, address, reg, data, dataSize, timeout);
+}
+
+error_t i2c_controller_write_register_array(Device* device, uint8_t address, const uint8_t* data, uint16_t dataSize, TickType_t timeout) {
+    const auto* driver = device_get_driver(device);
+    if (dataSize % 2 != 0) {
+        return ERROR_INVALID_ARGUMENT;
+    }
+    for (int i = 0; i < dataSize; i += 2) {
+        error_t error = I2C_DRIVER_API(driver)->write_register(device, address, data[i], &data[i + 1], 1, timeout);
+        if (error != ERROR_NONE) return error;
+    }
+    return ERROR_NONE;
+}
+
+error_t i2c_controller_has_device_at_address(Device* device, uint8_t address, TickType_t timeout) {
+    const auto* driver = device_get_driver(device);
+    uint8_t message[2] = { 0, 0 };
+    return I2C_DRIVER_API(driver)->write(device, address, message, 2, timeout);
+}
+
+const struct DeviceType I2C_CONTROLLER_TYPE {
+    .name = "i2c-controller"
+};
+
+}

TactilityKernel/source/drivers/i2s_controller.cpp

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: Apache-2.0
+#include <tactility/drivers/i2s_controller.h>
+#include <tactility/error.h>
+#include <tactility/device.h>
+
+#define I2S_DRIVER_API(driver) ((struct I2sControllerApi*)driver->api)
+
+extern "C" {
+
+error_t i2s_controller_read(Device* device, void* data, size_t dataSize, size_t* bytesRead, TickType_t timeout) {
+    const auto* driver = device_get_driver(device);
+    return I2S_DRIVER_API(driver)->read(device, data, dataSize, bytesRead, timeout);
+}
+
+error_t i2s_controller_write(Device* device, const void* data, size_t dataSize, size_t* bytesWritten, TickType_t timeout) {
+    const auto* driver = device_get_driver(device);
+    return I2S_DRIVER_API(driver)->write(device, data, dataSize, bytesWritten, timeout);
+}
+
+error_t i2s_controller_set_config(Device* device, const struct I2sConfig* config) {
+    const auto* driver = device_get_driver(device);
+    return I2S_DRIVER_API(driver)->set_config(device, config);
+}
+
+error_t i2s_controller_get_config(Device* device, struct I2sConfig* config) {
+    const auto* driver = device_get_driver(device);
+    return I2S_DRIVER_API(driver)->get_config(device, config);
+}
+
+error_t i2s_controller_reset(struct Device* device) {
+    const auto* driver = device_get_driver(device);
+    return I2S_DRIVER_API(driver)->reset(device);
+}
+
+const struct DeviceType I2S_CONTROLLER_TYPE {
+    .name = "i2s-controller"
+};
+
+}

TactilityKernel/source/drivers/root.cpp

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#include <tactility/device.h>
+#include <tactility/driver.h>
+#include <tactility/drivers/root.h>
+#include <cstring>
+
+extern "C" {
+
+bool root_is_model(const struct Device* device, const char* buffer) {
+    auto* config = static_cast<const RootConfig*>(device->config);
+    return strcmp(config->model, buffer) == 0;
+}
+
+Driver root_driver = {
+    .name = "root",
+    .compatible = (const char*[]) { "root", nullptr },
+    .start_device = nullptr,
+    .stop_device = nullptr,
+    .api = nullptr,
+    .device_type = nullptr,
+    .owner = nullptr,
+    .internal = nullptr
+};
+
+}

TactilityKernel/source/drivers/spi_controller.cpp

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: Apache-2.0
+#include <tactility/drivers/spi_controller.h>
+#include <tactility/error.h>
+#include <tactility/device.h>
+
+#define SPI_DRIVER_API(driver) ((struct SpiControllerApi*)driver->api)
+
+extern "C" {
+
+error_t spi_controller_lock(struct Device* device) {
+    const auto* driver = device_get_driver(device);
+    return SPI_DRIVER_API(driver)->lock(device);
+}
+
+error_t spi_controller_try_lock(struct Device* device, TickType_t timeout) {
+    const auto* driver = device_get_driver(device);
+    return SPI_DRIVER_API(driver)->try_lock(device, timeout);
+}
+
+error_t spi_controller_unlock(struct Device* device) {
+    const auto* driver = device_get_driver(device);
+    return SPI_DRIVER_API(driver)->unlock(device);
+}
+
+const struct DeviceType SPI_CONTROLLER_TYPE {
+    .name = "spi-controller"
+};
+
+}

TactilityKernel/source/drivers/uart_controller.cpp

@@ -0,0 +1,115 @@
+// SPDX-License-Identifier: Apache-2.0
+#include <tactility/drivers/uart_controller.h>
+#include <tactility/error.h>
+#include <tactility/device.h>
+#include <tactility/time.h>
+
+#define UART_DRIVER_API(driver) ((struct UartControllerApi*)driver->api)
+
+extern "C" {
+
+error_t uart_controller_read_byte(struct Device* device, uint8_t* out, TickType_t timeout) {
+    const auto* driver = device_get_driver(device);
+    return UART_DRIVER_API(driver)->read_byte(device, out, timeout);
+}
+
+error_t uart_controller_write_byte(struct Device* device, uint8_t out, TickType_t timeout) {
+    const auto* driver = device_get_driver(device);
+    return UART_DRIVER_API(driver)->write_byte(device, out, timeout);
+}
+
+error_t uart_controller_write_bytes(struct Device* device, const uint8_t* buffer, size_t buffer_size, TickType_t timeout) {
+    const auto* driver = device_get_driver(device);
+    return UART_DRIVER_API(driver)->write_bytes(device, buffer, buffer_size, timeout);
+}
+
+error_t uart_controller_read_bytes(struct Device* device, uint8_t* buffer, size_t buffer_size, TickType_t timeout) {
+    const auto* driver = device_get_driver(device);
+    return UART_DRIVER_API(driver)->read_bytes(device, buffer, buffer_size, timeout);
+}
+
+error_t uart_controller_read_until(struct Device* device, uint8_t* buffer, size_t buffer_size, uint8_t until_byte, bool add_null_terminator, size_t* bytes_read, TickType_t timeout) {
+    size_t read_count = 0;
+    TickType_t start_time = get_ticks();
+    uint8_t* buffer_write_ptr = buffer;
+    uint8_t* buffer_limit = buffer + buffer_size;
+    if (add_null_terminator) {
+        buffer_limit--;
+    }
+    TickType_t timeout_left = timeout;
+    error_t result = ERROR_NONE;
+
+    while (buffer_write_ptr < buffer_limit) {
+        result = uart_controller_read_byte(device, buffer_write_ptr, timeout_left);
+        if (result != ERROR_NONE) {
+            break;
+        }
+
+        read_count++;
+
+        if (*buffer_write_ptr == until_byte) {
+            if (add_null_terminator) {
+                buffer_write_ptr++;
+                *buffer_write_ptr = 0x00U;
+            }
+            break;
+        }
+
+        buffer_write_ptr++;
+
+        TickType_t now = get_ticks();
+        if (now > (start_time + timeout)) {
+            result = ERROR_TIMEOUT;
+            break;
+        } else {
+            timeout_left = timeout - (now - start_time);
+        }
+    }
+
+    if (bytes_read != nullptr) {
+        *bytes_read = read_count;
+    }
+
+    return result;
+}
+
+error_t uart_controller_get_available(struct Device* device, size_t* available) {
+    const auto* driver = device_get_driver(device);
+    return UART_DRIVER_API(driver)->get_available(device, available);
+}
+
+error_t uart_controller_set_config(struct Device* device, const struct UartConfig* config) {
+    const auto* driver = device_get_driver(device);
+    return UART_DRIVER_API(driver)->set_config(device, config);
+}
+
+error_t uart_controller_get_config(struct Device* device, struct UartConfig* config) {
+    const auto* driver = device_get_driver(device);
+    return UART_DRIVER_API(driver)->get_config(device, config);
+}
+
+error_t uart_controller_open(struct Device* device) {
+    const auto* driver = device_get_driver(device);
+    return UART_DRIVER_API(driver)->open(device);
+}
+
+error_t uart_controller_close(struct Device* device) {
+    const auto* driver = device_get_driver(device);
+    return UART_DRIVER_API(driver)->close(device);
+}
+
+bool uart_controller_is_open(struct Device* device) {
+    const auto* driver = device_get_driver(device);
+    return UART_DRIVER_API(driver)->is_open(device);
+}
+
+error_t uart_controller_flush_input(struct Device* device) {
+    const auto* driver = device_get_driver(device);
+    return UART_DRIVER_API(driver)->flush_input(device);
+}
+
+const struct DeviceType UART_CONTROLLER_TYPE {
+    .name = "uart-controller"
+};
+
+}