Implement posix app loading (#643)

- Added POSIX desktop support for SDK builds, application packaging, and integration testing.
- Added POSIX filesystem partitions and improved application path handling.
- Added simulator support for loading and running applications dynamically.
- Improved simulator task stack handling and display startup reliability.
- Improved simulator display scaling, resizing, high-DPI support, and pointer accuracy.
- Fixed LVGL timers and input polling on POSIX. (fixes simulator with Linux on some Intel graphics platforms)
- Standardized data paths across platforms.
- Logging now works via separate task: this allows apps to write to log without it affecting their stdout (for apps that output text as relevant date for other apps, like the File Selection app)
- Fixes for app stdio

Modules/app-module/CMakeLists.txt

@@ -10,3 +10,12 @@ tactility_add_module(app-module
     INCLUDE_DIRS include/
     REQUIRES TactilityKernel service-module minitar
 )
+
+# Tells source/io.cpp its real-syscall fallback must go through __real_read/write/close()
+# rather than calling ::read/::write/::close() directly, on every platform whose build wraps
+# those symbols (ESP-IDF always; POSIX except macOS, whose linker doesn't support --wrap) -
+# see Tactility/CMakeLists.txt and the top-level CMakeLists.txt for where that's applied.
+if (NOT APPLE)
+    tactility_get_module_name(app-module MODULE_NAME)
+    target_compile_definitions(${MODULE_NAME} PRIVATE TT_APP_IO_WRAPS_STDIO)
+endif ()

Modules/app-module/include/app/manager.h

@@ -111,6 +111,23 @@ struct AppStreamBinding {
  */
 error_t app_manager_start_with_streams(const char* id, const struct AppStreamBinding* bindings, size_t binding_count, AppInstanceId* out_app_instance_id);
 
+/**
+ * Combines app_manager_start_for_result() and app_manager_start_with_streams(): starts @a id as
+ * a modal child of @a parent_instance_id (see app_manager_start_for_result()'s own doc for the
+ * result-delivery contract) with @a bindings installed into its fd table before its task begins
+ * executing (see app_manager_start_with_streams()'s own doc for stream ownership). For a child
+ * that needs to hand back more than an int32_t (e.g. a path) via its own stdout instead of the
+ * "get last result" getter pattern (see app_manager_start_for_result()) - see e.g.
+ * tt::app::fileselection::startForExistingFile().
+ * @param[in] argv see app_manager_start_for_result().
+ * @param[in] bindings see app_manager_start_with_streams().
+ * @retval ERROR_NOT_FOUND no manifest with this id is registered, or no AppLoaderApi is registered
+ * @retval ERROR_OUT_OF_RANGE a binding's producer_fd is out of range
+ * @retval ERROR_RESOURCE a binding's event_group has no free bits left to claim
+ * @retval ERROR_NONE on success
+ */
+error_t app_manager_start_for_result_with_streams(const char* id, AppInstanceId parent_instance_id, int argc, const char* const argv[], const struct AppStreamBinding* bindings, size_t binding_count, AppInstanceId* out_app_instance_id);
+
 /**
  * Stop an app instance permanently. Emits APP_EVENT_CLOSE and bound-waits for its task to exit
  * if it was running.

Modules/app-module/source/io.cpp

@@ -7,7 +7,7 @@
 
 #include <cerrno>
 
-#ifdef ESP_PLATFORM
+#if defined(TT_APP_IO_WRAPS_STDIO)
 extern "C" {
 ssize_t __real_read(int fd, void* buffer, size_t size);
 ssize_t __real_write(int fd, const void* buffer, size_t size);
@@ -56,7 +56,7 @@ ssize_t app_io_read(int fd, void* buffer, size_t size) {
         errno = EBADF;
         return -1;
     }
-#ifdef ESP_PLATFORM
+#if defined(TT_APP_IO_WRAPS_STDIO)
     return __real_read(fd, buffer, size);
 #else
     return ::read(fd, buffer, size);
@@ -71,13 +71,25 @@ ssize_t app_io_write(int fd, const void* buffer, size_t size) {
         if (file.ops->release != nullptr) {
             file.ops->release(file.object);
         }
+        // Tee to the real fd too: a bound stream only exists because a parent explicitly asked
+        // to capture this app instance's own output (see AppStreamBinding), but generic code
+        // running on that same instance's thread - most commonly the platform's own logging
+        // (LOG_I/etc, which calls write() the same as anything else) - has no way to know its
+        // output is currently being intercepted. Without this, a log line emitted while any app
+        // instance has its stdout captured would vanish from the console entirely instead of
+        // just also being visible to the capturing parent.
+#if defined(TT_APP_IO_WRAPS_STDIO)
+        __real_write(fd, buffer, size);
+#else
+        ::write(fd, buffer, size);
+#endif
         return result;
     }
     if (table != nullptr && app_fd_table_is_app_owned(table, fd)) {
         errno = EBADF;
         return -1;
     }
-#ifdef ESP_PLATFORM
+#if defined(TT_APP_IO_WRAPS_STDIO)
     return __real_write(fd, buffer, size);
 #else
     return ::write(fd, buffer, size);
@@ -96,7 +108,7 @@ int app_io_close(int fd) {
             return -1;
         }
     }
-#ifdef ESP_PLATFORM
+#if defined(TT_APP_IO_WRAPS_STDIO)
     return __real_close(fd);
 #else
     return ::close(fd);

Modules/app-module/source/manager.cpp

@@ -178,6 +178,10 @@ error_t app_manager_start_with_streams(const char* id, const AppStreamBinding* b
     return start_internal(id, 0, 0, nullptr, bindings, binding_count, out_app_instance_id);
 }
 
+error_t app_manager_start_for_result_with_streams(const char* id, AppInstanceId parent_instance_id, int argc, const char* const argv[], const AppStreamBinding* bindings, size_t binding_count, AppInstanceId* out_app_instance_id) {
+    return start_internal(id, parent_instance_id, argc, copy_arguments(argc, argv), bindings, binding_count, out_app_instance_id);
+}
+
 error_t app_manager_stop(AppInstanceId app_instance_id) {
     return app_scheduler_stop(app_instance_id, pdMS_TO_TICKS(2000));
 }

Modules/app-module/source/module.cpp

@@ -38,6 +38,7 @@ static const ModuleSymbol SYMBOLS[] = {
     DEFINE_MODULE_SYMBOL(app_manager_start_with_parameters),
     DEFINE_MODULE_SYMBOL(app_manager_start_for_result),
     DEFINE_MODULE_SYMBOL(app_manager_start_with_streams),
+    DEFINE_MODULE_SYMBOL(app_manager_start_for_result_with_streams),
     DEFINE_MODULE_SYMBOL(app_manager_stop),
     DEFINE_MODULE_SYMBOL(app_manager_get_state),
     DEFINE_MODULE_SYMBOL(app_manager_find_manifest),

Modules/app-module/source/scheduler.cpp

@@ -199,12 +199,19 @@ void app_task_main(void* context) {
     check(pvTaskGetThreadLocalStoragePointer(nullptr, APP_INSTANCE_ID_THREAD_SLOT_INDEX) == nullptr);
     vTaskSetThreadLocalStoragePointer(nullptr, APP_INSTANCE_ID_THREAD_SLOT_INDEX, reinterpret_cast<void*>(static_cast<uintptr_t>(ctx->app_instance_id)));
 
+    // Debug logging so it's invisible by default
+    // When logging happens, it can distort the application stdout, which breaks apps that use
+    // stdout to output important information, such as the file selection dialog app.
     LOG_I(TAG, "[instance %lu] Task started", ctx->app_instance_id);
 
     set_state(ctx->app_instance_id, APP_INSTANCE_STATE_ACTIVE);
 
     int32_t result = ctx->loader->run(ctx->runtime, ctx->app_instance_id, ctx->argc, ctx->argv);
 
+    // The platform might buffer stdout (e.g. esp-idf with newlib)
+    // Do a manual flush to ensure data has been written:
+    fflush(stdout);
+
     vTaskSetThreadLocalStoragePointer(nullptr, APP_INSTANCE_ID_THREAD_SLOT_INDEX, nullptr);
 
     ctx->loader->unload(ctx->runtime);

Modules/app-module/tests/CMakeLists.txt

@@ -6,10 +6,31 @@ enable_language(C CXX ASM)
 file(GLOB_RECURSE TEST_SOURCES CONFIGURE_DEPENDS ${PROJECT_SOURCE_DIR}/source/*.cpp)
 add_executable(AppModuleTests EXCLUDE_FROM_ALL ${TEST_SOURCES})
 
+if (NOT APPLE)
+    # Provides __wrap_read/write/close for the -Wl,--wrap= below (see Tactility/CMakeLists.txt
+    # for the canonical pairing of this file with those flags).
+    target_sources(AppModuleTests PRIVATE ${CMAKE_CURRENT_LIST_DIR}/../../../Tactility/Source/AppStdioWrap.cpp)
+endif ()
+
 target_include_directories(AppModuleTests PRIVATE ${DOCTESTINC})
 
 add_test(NAME AppModuleTests COMMAND AppModuleTests)
 
+# Matches app-module's own TT_APP_IO_WRAPS_STDIO (see Modules/app-module/CMakeLists.txt):
+# io.cpp calls __real_read/write/close() on non-Apple POSIX, so any final link of it needs
+# these wraps too, or those symbols go unresolved. The printf-family/getc-family flags are
+# needed for the same reason: AppStdioWrap.cpp compiles those __wrap_* functions unconditionally
+# on this platform (see its own #if guard), and they reference __real_vfprintf/fputs/fputc/
+# fgetc/fgets - those only exist once the matching --wrap flag is passed.
+if (NOT APPLE)
+    target_link_options(AppModuleTests PRIVATE
+        "-Wl,--wrap=read" "-Wl,--wrap=write" "-Wl,--wrap=close"
+        "-Wl,--wrap=printf" "-Wl,--wrap=fprintf" "-Wl,--wrap=vprintf" "-Wl,--wrap=vfprintf"
+        "-Wl,--wrap=puts" "-Wl,--wrap=fputs" "-Wl,--wrap=putchar" "-Wl,--wrap=fputc"
+        "-Wl,--wrap=getchar" "-Wl,--wrap=fgetc" "-Wl,--wrap=fgets"
+    )
+endif ()
+
 target_link_libraries(AppModuleTests PUBLIC
     TactilityKernel
     app-module