.gitmodules

@@ -10,6 +10,3 @@
 [submodule "Libraries/SDL"]
 	path = Libraries/SDL
 	url = https://github.com/libsdl-org/SDL.git
-[submodule "Libraries/minitar/minitar"]
-	path = Libraries/minitar/minitar
-	url = git@github.com:gabscoarnec/minitar.git

CMakeLists.txt

@@ -41,7 +41,6 @@ if (DEFINED ENV{ESP_IDF_VERSION})
         "Libraries/elf_loader"
         "Libraries/lvgl"
         "Libraries/lv_screenshot"
-        "Libraries/minitar"
         "Libraries/minmea"
         "Libraries/QRCode"
     )
@@ -79,7 +78,6 @@ if (NOT DEFINED ENV{ESP_IDF_VERSION})
     add_subdirectory(Libraries/FreeRTOS-Kernel)
     add_subdirectory(Libraries/lv_screenshot)
     add_subdirectory(Libraries/QRCode)
-    add_subdirectory(Libraries/minitar)
     add_subdirectory(Libraries/minmea)
     target_compile_definitions(freertos_kernel PUBLIC "projCOVERAGE_TEST=0")
     target_include_directories(freertos_kernel

Documentation/ideas.md

@@ -19,12 +19,9 @@
 - Apps with update timer should check `lvgl::isStarted()`
 - CrowPanel Basic 3.5": check why GraphicsDemo fails
 - CrowPanel Basic 3.5": check why System Info doesn't show storage info
-- Update to LVGL v9.3 stable
 
 ## Medium Priority
 
-- Make WiFi setup app that starts an access point and hosts a webpage to set up the device.
-  This will be useful for devices without a screen, a small screen or a non-touch screen.
 - Unify the way displays are dimmed. Some implementations turn off the display when it's fully dimmed. Make this a separate functionality.
 - Try out ILI9342 https://github.com/jbrilha/esp_lcd_ili9342
 - All drivers (e.g. display, touch, etc.) should call stop() in their destructor, or at least assert that they should not be running.
@@ -66,7 +63,6 @@
 - Capacity based on voltage: estimation for various devices uses a linear voltage curve, but it should use some sort of battery discharge curve.
 - Statusbar widget to show how much memory is in use?
 - Wrapper for lvgl slider widget that shows "+" and "-" buttons, and also the value in a label.
-  Note: consider Spinbox
 - Files app: copy/paste actions
 - On crash, try to save the current log to flash or SD card? (this is risky, though, so ask in Discord first)
 - Support more than 1 hardware keyboard (see lvgl::hardware_keyboard_set_indev()). LVGL init currently calls keyboard init, but that part should probably be done from the KeyboardDevice base class.

ExternalApps/HelloWorld/.gitignore

@@ -1,2 +1,2 @@
-build/
+build*/
 .tactility/

ExternalApps/HelloWorld/assets/message.txt

@@ -1 +0,0 @@
-Hello, world!

ExternalApps/HelloWorld/manifest.properties

@@ -1,13 +0,0 @@
-[manifest]
-version=0.1
-[target]
-sdk=0.5.0
-platforms=esp32,esp32s3
-[app]
-id=com.bytewelder.helloworld
-version=0.1.0
-name=Hello World
-description=A demonstration app that says hi
-[author]
-name=ByteWelder
-website=https://bytewelder.com

ExternalApps/HelloWorld/tactility.properties

@@ -0,0 +1,2 @@
+[sdk]
+version = 0.5.0

ExternalApps/HelloWorld/tactility.py

@@ -8,19 +8,22 @@ import subprocess
 import time
 import urllib.request
 import zipfile
-import requests
-import tarfile
-import shutil
-import configparser
 
+import requests
+
+# Targetable platforms that represent a specific hardware target
+platform_targets = ["esp32", "esp32s3"]
+# All valid platform commandline arguments
+platform_arguments = platform_targets.copy()
+platform_arguments.append("all")
 ttbuild_path = ".tactility"
-ttbuild_version = "2.0.0"
+ttbuild_version = "1.2.1"
+ttbuild_properties_file = "tactility.properties"
 ttbuild_cdn = "https://cdn.tactility.one"
 ttbuild_sdk_json_validity = 3600  # seconds
 ttport = 6666
 verbose = False
 use_local_sdk = False
-valid_platforms = ["esp32", "esp32s3"]
 
 spinner_pattern = [
     "⠋",
@@ -70,8 +73,6 @@ def print_help():
     print("  --skip-build                             Run everything except the idf.py/CMake commands")
     print("  --verbose                                Show extra console output")
 
-# region Core
-
 def download_file(url, filepath):
     global verbose
     if verbose:
@@ -107,19 +108,25 @@ def exit_with_error(message):
 def get_url(ip, path):
     return f"http://{ip}:{ttport}{path}"
 
-def read_properties_file(path):
+def is_valid_platform_name(name):
-    config = configparser.RawConfigParser()
+    global platform_arguments
-    config.read(path)
+    return name in platform_arguments
-    return config
 
-#endregion Core
+def validate_environment():
+    global ttbuild_properties_file, use_local_sdk
+    if os.environ.get("IDF_PATH") is None:
+        exit_with_error("Cannot find the Espressif IDF SDK. Ensure it is installed and that it is activated via $PATH_TO_IDF_SDK/export.sh")
+    if not os.path.exists(ttbuild_properties_file):
+        exit_with_error(f"{ttbuild_properties_file} file not found")
+    if use_local_sdk == False and os.environ.get("TACTILITY_SDK_PATH") is not None:
+        print_warning("TACTILITY_SDK_PATH is set, but will be ignored by this command.")
+        print_warning("If you want to use it, use the 'build local' parameters.")
+    elif use_local_sdk == True and os.environ.get("TACTILITY_SDK_PATH") is None:
+        exit_with_error("local build was requested, but TACTILITY_SDK_PATH environment variable is not set.")
 
-#region SDK helpers
+def setup_environment():
-
+    global ttbuild_path
-def read_sdk_json():
+    os.makedirs(ttbuild_path, exist_ok=True)
-    json_file_path = os.path.join(ttbuild_path, "sdk.json")
-    json_file = open(json_file_path)
-    return json.load(json_file)
 
 def get_sdk_dir(version, platform):
     global use_local_sdk
@@ -129,6 +136,15 @@ def get_sdk_dir(version, platform):
         global ttbuild_cdn
         return os.path.join(ttbuild_path, f"{version}-{platform}", "TactilitySDK")
 
+def get_sdk_version():
+    global ttbuild_properties_file
+    parser = configparser.RawConfigParser()
+    parser.read(ttbuild_properties_file)
+    sdk_dict = dict(parser.items("sdk"))
+    if not "version" in sdk_dict:
+        exit_with_error(f"Could not find 'version' in [sdk] section in {ttbuild_properties_file}")
+    return sdk_dict["version"]
+
 def get_sdk_root_dir(version, platform):
     global ttbuild_cdn
     return os.path.join(ttbuild_path, f"{version}-{platform}")
@@ -159,34 +175,20 @@ def update_sdk_json():
     json_filepath = os.path.join(ttbuild_path, "sdk.json")
     return download_file(json_url, json_filepath)
 
-def should_fetch_sdkconfig_files(platform_targets):
+def should_fetch_sdkconfig_files():
     for platform in platform_targets:
         sdkconfig_filename = f"sdkconfig.app.{platform}"
         if not os.path.exists(os.path.join(ttbuild_path, sdkconfig_filename)):
             return True
     return False
 
-def fetch_sdkconfig_files(platform_targets):
+def fetch_sdkconfig_files():
     for platform in platform_targets:
         sdkconfig_filename = f"sdkconfig.app.{platform}"
         target_path = os.path.join(ttbuild_path, sdkconfig_filename)
         if not download_file(f"{ttbuild_cdn}/{sdkconfig_filename}", target_path):
             exit_with_error(f"Failed to download sdkconfig file for {platform}")
 
-#endregion SDK helpers
-
-#region Validation
-
-def validate_environment():
-    if os.environ.get("IDF_PATH") is None:
-        exit_with_error("Cannot find the Espressif IDF SDK. Ensure it is installed and that it is activated via $PATH_TO_IDF_SDK/export.sh")
-    if not os.path.exists("manifest.properties"):
-        exit_with_error("manifest.properties not found")
-    if use_local_sdk == False and os.environ.get("TACTILITY_SDK_PATH") is not None:
-        print_warning("TACTILITY_SDK_PATH is set, but will be ignored by this command.")
-        print_warning("If you want to use it, use the 'build local' parameters.")
-    elif use_local_sdk == True and os.environ.get("TACTILITY_SDK_PATH") is None:
-        exit_with_error("local build was requested, but TACTILITY_SDK_PATH environment variable is not set.")
 
 def validate_version_and_platforms(sdk_json, sdk_version, platforms_to_build):
     version_map = sdk_json["versions"]
@@ -215,64 +217,6 @@ def validate_self(sdk_json):
         print_error("Run 'tactility.py updateself' to update.")
         sys.exit(1)
 
-#endregion Validation
-
-#region Manifest
-
-def read_manifest():
-    return read_properties_file("manifest.properties")
-
-def validate_manifest(manifest):
-    # [manifest]
-    if not "manifest" in manifest:
-        exit_with_error("Invalid manifest format: [manifest] not found")
-    if not "version" in manifest["manifest"]:
-        exit_with_error("Invalid manifest format: [manifest] version not found")
-    # [target]
-    if not "target" in manifest:
-        exit_with_error("Invalid manifest format: [target] not found")
-    if not "sdk" in manifest["target"]:
-        exit_with_error("Invalid manifest format: [target] sdk not found")
-    if not "platforms" in manifest["target"]:
-        exit_with_error("Invalid manifest format: [target] platforms not found")
-    # [app]
-    if not "app" in manifest:
-        exit_with_error("Invalid manifest format: [app] not found")
-    if not "id" in manifest["app"]:
-        exit_with_error("Invalid manifest format: [app] id not found")
-    if not "version" in manifest["app"]:
-        exit_with_error("Invalid manifest format: [app] version not found")
-    if not "name" in manifest["app"]:
-        exit_with_error("Invalid manifest format: [app] name not found")
-    if not "description" in manifest["app"]:
-        exit_with_error("Invalid manifest format: [app] description not found")
-    # [author]
-    if not "author" in manifest:
-        exit_with_error("Invalid manifest format: [author] not found")
-    if not "name" in manifest["author"]:
-        exit_with_error("Invalid manifest format: [author] name not found")
-    if not "website" in manifest["author"]:
-        exit_with_error("Invalid manifest format: [author] website not found")
-
-def is_valid_manifest_platform(manifest, platform):
-    manifest_platforms = manifest["target"]["platforms"].split(",")
-    return platform in manifest_platforms
-
-def validate_manifest_platform(manifest, platform):
-    if not is_valid_manifest_platform(manifest, platform):
-        exit_with_error(f"Platform {platform} is not available in the manifest.")
-
-def get_manifest_target_platforms(manifest, requested_platform):
-    if requested_platform == "" or requested_platform is None:
-        return manifest["target"]["platforms"].split(",")
-    else:
-        validate_manifest_platform(manifest, requested_platform)
-        return [requested_platform]
-
-#endregion Manifest
-
-#region SDK download
-
 def sdk_download(version, platform):
     sdk_root_dir = get_sdk_root_dir(version, platform)
     os.makedirs(sdk_root_dir, exist_ok=True)
@@ -296,19 +240,12 @@ def sdk_download_all(version, platforms):
                 print(f"Using cached download for SDK version {version} and platform {platform}")
     return True
 
-#endregion SDK download
-
-#region Building
-
-def get_cmake_path(platform):
-    return os.path.join("build", f"cmake-build-{platform}")
-
 def find_elf_file(platform):
-    cmake_dir = get_cmake_path(platform)
+    build_dir = f"build-{platform}"
-    if os.path.exists(cmake_dir):
+    if os.path.exists(build_dir):
-        for file in os.listdir(cmake_dir):
+        for file in os.listdir(build_dir):
             if file.endswith(".app.elf"):
-                return os.path.join(cmake_dir, file)
+                return os.path.join(build_dir, file)
     return None
 
 def build_all(version, platforms, skip_build):
@@ -358,8 +295,7 @@ def build_first(version, platform, skip_build):
     if skip_build:
         return True
     print("Building first build")
-    cmake_path = get_cmake_path(platform)
+    with subprocess.Popen(["idf.py", "-B", f"build-{platform}", "build"], stdout=subprocess.PIPE, stderr=subprocess.STDOUT) as process:
-    with subprocess.Popen(["idf.py", "-B", cmake_path, "build"], stdout=subprocess.PIPE, stderr=subprocess.STDOUT) as process:
         build_output = wait_for_build(process, platform)
         # The return code is never expected to be 0 due to a bug in the elf cmake script, but we keep it just in case
         if process.returncode == 0:
@@ -384,8 +320,7 @@ def build_consecutively(version, platform, skip_build):
     os.system(f"cp {sdkconfig_path} sdkconfig")
     if skip_build:
         return True
-    cmake_path = get_cmake_path(platform)
+    with subprocess.Popen(["idf.py", "-B", f"build-{platform}", "elf"], stdout=subprocess.PIPE, stderr=subprocess.STDOUT) as process:
-    with subprocess.Popen(["idf.py", "-B", cmake_path, "elf"], stdout=subprocess.PIPE, stderr=subprocess.STDOUT) as process:
         build_output = wait_for_build(process, platform)
         if process.returncode == 0:
             print(f"{shell_color_green}Building for {platform} ✅{shell_color_reset}")
@@ -396,86 +331,41 @@ def build_consecutively(version, platform, skip_build):
             print(f"{shell_color_red}Building for {platform} failed ❌{shell_color_reset}")
             return False
 
-#endregion Building
+def read_sdk_json():
+    json_file_path = os.path.join(ttbuild_path, "sdk.json")
+    json_file = open(json_file_path)
+    return json.load(json_file)
 
-#region Packaging
+def build_action(platform_arg):
-
-def package_intermediate_manifest(target_path):
-    if not os.path.isfile("manifest.properties"):
-        print_error("manifest.properties not found")
-        return
-    shutil.copy("manifest.properties", os.path.join(target_path, "manifest.properties"))
-
-def package_intermediate_binaries(target_path, platforms):
-    elf_dir = os.path.join(target_path, "elf")
-    os.makedirs(elf_dir, exist_ok=True)
-    for platform in platforms:
-        elf_path = find_elf_file(platform)
-        if elf_path is None:
-            print_error(f"ELF file not found at {elf_path}")
-            return
-        shutil.copy(elf_path, os.path.join(elf_dir, f"{platform}.elf"))
-
-def package_intermediate_assets(target_path):
-    if os.path.isdir("assets"):
-        shutil.copytree("assets", os.path.join(target_path, "assets"), dirs_exist_ok=True)
-
-def package_intermediate(platforms):
-    target_path = os.path.join("build", "package-intermediate")
-    if os.path.isdir(target_path):
-        shutil.rmtree(target_path)
-    os.makedirs(target_path, exist_ok=True)
-    package_intermediate_manifest(target_path)
-    package_intermediate_binaries(target_path, platforms)
-    package_intermediate_assets(target_path)
-
-def package_name(platforms):
-    elf_path = find_elf_file(platforms[0])
-    elf_base_name = os.path.basename(elf_path).removesuffix(".app.elf")
-    return os.path.join("build", f"{elf_base_name}.app")
-
-def package_all(platforms):
-    print("Packaging app")
-    package_intermediate(platforms)
-    # Create build/something.app
-    tar_path = package_name(platforms)
-    tar = tarfile.open(tar_path, mode="w", format=tarfile.USTAR_FORMAT)
-    tar.add(os.path.join("build", "package-intermediate"), arcname="")
-    tar.close()
-
-#endregion Packaging
-
-def setup_environment():
-    global ttbuild_path
-    os.makedirs(ttbuild_path, exist_ok=True)
-
-def build_action(manifest, platform_arg):
     # Environment validation
     validate_environment()
-    platforms_to_build = get_manifest_target_platforms(manifest, platform_arg)
+    platforms_to_build = platform_targets if platform_arg == "all" else [platform_arg]
+    if not is_valid_platform_name(platform_arg):
+        print_help()
+        exit_with_error("Invalid platform name")
     if not use_local_sdk:
-        if should_fetch_sdkconfig_files(platforms_to_build):
+        if should_fetch_sdkconfig_files():
-            fetch_sdkconfig_files(platforms_to_build)
+            fetch_sdkconfig_files()
         sdk_json = read_sdk_json()
         validate_self(sdk_json)
         if not "versions" in sdk_json:
             exit_with_error("Version data not found in sdk.json")
     # Build
-    sdk_version = manifest["target"]["sdk"]
+    sdk_version = get_sdk_version()
     if not use_local_sdk:
         validate_version_and_platforms(sdk_json, sdk_version, platforms_to_build)
         if not sdk_download_all(sdk_version, platforms_to_build):
             exit_with_error("Failed to download one or more SDKs")
-    #TODO uncomment
+    build_all(sdk_version, platforms_to_build, skip_build)  # Environment validation
-    #build_all(sdk_version, platforms_to_build, skip_build)  # Environment validation
-    if not skip_build:
-        package_all(platforms_to_build)
 
 def clean_action():
-    if os.path.exists("build"):
+    count = 0
-        print(f"Removing build/")
+    for path in os.listdir("."):
-        shutil.rmtree("build")
+        if path.startswith("build-"):
-    else:
+            print(f"Removing {path}/")
+            shutil.rmtree(path)
+            count = count + 1
+    if count == 0:
         print("Nothing to clean")
 
 def clear_cache_action():
@@ -506,8 +396,7 @@ def get_device_info(ip):
     except requests.RequestException as e:
         print(f"Request failed: {e}")
 
-def run_action(manifest, ip):
+def run_action(ip, app_id):
-    app_id = manifest["app"]["id"]
     print(f"Running {app_id} on {ip}")
     url = get_url(ip, "/app/run")
     params = {'id': app_id}
@@ -520,13 +409,16 @@ def run_action(manifest, ip):
     except requests.RequestException as e:
         print(f"Request failed: {e}")
 
-def install_action(manifest, ip, platforms):
+def install_action(ip, platform):
-    package_path = package_name(platforms)
+    file_path = find_elf_file(platform)
-    print(f"Installing {package_path} to {ip}")
+    if file_path is None:
+        print_error(f"File not found: {file_path}")
+        return
+    print(f"Installing {file_path} to {ip}")
     url = get_url(ip, "/app/install")
     try:
         # Prepare multipart form data
-        with open(package_path, 'rb') as file:
+        with open(file_path, 'rb') as file:
             files = {
                 'elf': file
             }
@@ -540,7 +432,6 @@ def install_action(manifest, ip, platforms):
     except IOError as e:
         print_error(f"File error: {e}")
 
-#region Main
 
 if __name__ == "__main__":
     print(f"Tactility Build System v{ttbuild_version}")
@@ -557,23 +448,15 @@ if __name__ == "__main__":
     use_local_sdk = "--local-sdk" in sys.argv
     # Environment setup
     setup_environment()
-    if not os.path.isfile("manifest.properties"):
-        exit_with_error("manifest.properties not found")
-    manifest = read_manifest()
-    validate_manifest(manifest)
-    all_platform_targets = manifest["target"]["platforms"].split(",")
     # Update SDK cache (sdk.json)
     if should_update_sdk_json() and not update_sdk_json():
         exit_with_error("Failed to retrieve SDK info")
     # Actions
     if action_arg == "build":
-        if len(sys.argv) < 2:
+        if len(sys.argv) < 3:
             print_help()
             exit_with_error("Commandline parameter missing")
-        platform = None
+        build_action(sys.argv[2])
-        if len(sys.argv) > 2:
-            platform = sys.argv[2]
-        build_action(manifest, platform)
     elif action_arg == "clean":
         clean_action()
     elif action_arg == "clearcache":
@@ -584,14 +467,12 @@ if __name__ == "__main__":
         if len(sys.argv) < 4:
             print_help()
             exit_with_error("Commandline parameter missing")
-        run_action(manifest, sys.argv[2], sys.argv[3])
+        run_action(sys.argv[2], sys.argv[3])
     elif action_arg == "install":
-        if len(sys.argv) < 3:
+        if len(sys.argv) < 4:
             print_help()
             exit_with_error("Commandline parameter missing")
-        install_action(manifest, sys.argv[2], all_platform_targets)
+        install_action(sys.argv[2], sys.argv[3])
     else:
         print_help()
         exit_with_error("Unknown commandline parameter")
-
-#endregion Main

Libraries/minitar/CMakeLists.txt

@@ -1,22 +0,0 @@
-cmake_minimum_required(VERSION 3.20)
-
-set(C_STANDARD 11)
-set(CC_STANDARD_REQUIRED ON)
-
-if (DEFINED ENV{ESP_IDF_VERSION})
-    idf_component_register(
-        SRC_DIRS "minitar/src/"
-        INCLUDE_DIRS "minitar/"
-    )
-
-else()
-    file(GLOB SOURCES "minitar/src/*.*")
-    file(GLOB HEADERS "minitar/*.h")
-
-    add_library(minitar STATIC)
-
-    target_sources(minitar PRIVATE ${SOURCES})
-    include_directories(minitar "minitar/src/")
-    target_include_directories(minitar PUBLIC "minitar/")
-
-endif()

Libraries/minitar/minitar

@@ -1 +1 @@
-Subproject commit 78c254ba114f6b66d888149d4ad0eff178dceb88
+Subproject commit 7fcd690add04dda0af49741221d49c6d597c546b

Tactility/CMakeLists.txt

@@ -6,7 +6,7 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON)
 if (DEFINED ENV{ESP_IDF_VERSION})
     file(GLOB_RECURSE SOURCE_FILES Source/*.c*)
 
-    list(APPEND REQUIRES_LIST TactilityCore lvgl driver elf_loader lv_screenshot QRCode esp_lvgl_port minitar minmea esp_wifi nvs_flash spiffs vfs fatfs lwip esp_http_server)
+    list(APPEND REQUIRES_LIST TactilityCore lvgl driver elf_loader lv_screenshot QRCode esp_lvgl_port minmea esp_wifi nvs_flash spiffs vfs fatfs lwip esp_http_server)
     if ("${IDF_TARGET}" STREQUAL "esp32s3")
         list(APPEND REQUIRES_LIST esp_tinyusb)
     endif ()
@@ -55,7 +55,6 @@ else()
         PUBLIC lvgl
         PUBLIC lv_screenshot
         PUBLIC minmea
-        PUBLIC minitar
     )
 endif()
 

Tactility/Include/Tactility/app/App.h

@@ -94,10 +94,4 @@ std::shared_ptr<AppContext> _Nullable getCurrentAppContext();
 /** @return the currently running app (it is only ever null before the splash screen is shown) */
 std::shared_ptr<App> _Nullable getCurrentApp();
 
-std::string getTempPath();
-
-std::string getInstallPath();
-
-bool install(const std::string& path);
-
 }

Tactility/Source/app/App.cpp

@@ -1,4 +1,5 @@
-#include <Tactility/app/App.h>
+#include "Tactility/app/App.h"
+
 #include <Tactility/service/loader/Loader.h>
 
 namespace tt::app {

Tactility/Source/app/AppInstall.cpp

@@ -1,212 +0,0 @@
-#include <Tactility/app/App.h>
-
-#include <minitar.h>
-
-#include <errno.h>
-#include <fcntl.h>
-#include <libgen.h>
-#include <map>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/types.h>
-#include <unistd.h>
-#include <Tactility/MountPoints.h>
-#include <Tactility/file/File.h>
-#include <Tactility/file/FileLock.h>
-#include <Tactility/file/PropertiesFile.h>
-#include <Tactility/hal/Device.h>
-#include <Tactility/hal/sdcard/SdCardDevice.h>
-
-constexpr auto* TAG = "App";
-
-namespace tt::app {
-
-static int untar_file(const minitar_entry* entry, const void* buf, const std::string& destinationPath) {
-    auto absolute_path = destinationPath + "/" + entry->metadata.path;
-    if (!file::findOrCreateDirectory(destinationPath, 0777)) return 1;
-
-    int fd = open(absolute_path.c_str(), O_WRONLY | O_CREAT | O_EXCL | O_CLOEXEC, 0644);
-    if (fd < 0) return 1;
-
-    if (write(fd, buf, entry->metadata.size) < 0) return 1;
-
-    // Note: fchmod() doesn't exist on ESP-IDF and chmod() does nothing on that platform
-    if (chmod(absolute_path.c_str(), entry->metadata.mode) < 0) return 1;
-
-    return close(fd);
-}
-
-static bool untar_directory(const minitar_entry* entry, const std::string& destinationPath) {
-    auto absolute_path = destinationPath + "/" + entry->metadata.path;
-    if (!file::findOrCreateDirectory(absolute_path, 0777)) return false;
-    return true;
-}
-
-bool untar(const std::string& tarPath, const std::string& destinationPath) {
-    minitar mp;
-    if (minitar_open(tarPath.c_str(), &mp) != 0) {
-        perror(tarPath.c_str());
-        return 1;
-    }
-    bool success = true;
-    minitar_entry entry;
-
-    do {
-        if (minitar_read_entry(&mp, &entry) == 0) {
-            TT_LOG_I(TAG, "Extracting %s", entry.metadata.path);
-            if (entry.metadata.type == MTAR_DIRECTORY) {
-                if (!strcmp(entry.metadata.name, ".") || !strcmp(entry.metadata.name, "..") || !strcmp(entry.metadata.name, "/")) continue;
-                if (!untar_directory(&entry, destinationPath)) {
-                    fprintf(stderr, "Failed to create directory %s/%s: %s\n", destinationPath.c_str(), entry.metadata.name, strerror(errno));
-                    success = false;
-                    break;
-                }
-            } else if (entry.metadata.type == MTAR_REGULAR) {
-                auto ptr = static_cast<char*>(malloc(entry.metadata.size));
-                if (!ptr) {
-                    perror("malloc");
-                    success = false;
-                    break;
-                }
-
-                minitar_read_contents(&mp, &entry, ptr, entry.metadata.size);
-
-                int status = untar_file(&entry, ptr, destinationPath);
-
-                free(ptr);
-
-                if (status != 0) {
-                    fprintf(stderr, "Failed to extract file %s: %s\n", entry.metadata.path, strerror(errno));
-                    success = false;
-                    break;
-                }
-            } else if (entry.metadata.type == MTAR_SYMLINK) {
-                TT_LOG_E(TAG, "SYMLINK not supported");
-            } else if (entry.metadata.type == MTAR_HARDLINK) {
-                TT_LOG_E(TAG, "HARDLINK not supported");
-            } else if (entry.metadata.type == MTAR_FIFO) {
-                TT_LOG_E(TAG, "FIFO not supported");
-            } else if (entry.metadata.type == MTAR_BLKDEV) {
-                TT_LOG_E(TAG, "BLKDEV not supported");
-            } else if (entry.metadata.type == MTAR_CHRDEV) {
-                TT_LOG_E(TAG, "CHRDEV not supported");
-            } else {
-                fprintf(stderr, "error: unknown entry type: %d", entry.metadata.type);
-                success = false;
-                break;
-            }
-        } else break;
-    } while (true);
-    minitar_close(&mp);
-    return success;
-}
-
-bool findFirstMountedSdCardPath(std::string& path) {
-    // const auto sdcards = hal::findDevices<hal::sdcard::SdCardDevice>(hal::Device::Type::SdCard);
-    bool is_set = false;
-    hal::findDevices<hal::sdcard::SdCardDevice>(hal::Device::Type::SdCard, [&is_set, &path](const auto& device) {
-        if (device->isMounted()) {
-            path = device->getMountPath();
-            is_set = true;
-            return false; // stop iterating
-        } else {
-            return true;
-        }
-    });
-    return is_set;
-}
-
-std::string getTempPath() {
-    std::string root_path;
-    if (!findFirstMountedSdCardPath(root_path)) {
-        root_path = file::MOUNT_POINT_DATA;
-    }
-    return root_path + "/tmp";
-}
-
-std::string getInstallPath() {
-    std::string root_path;
-    if (!findFirstMountedSdCardPath(root_path)) {
-        root_path = file::MOUNT_POINT_DATA;
-    }
-    return root_path + "/apps";
-}
-
-bool install(const std::string& path) {
-    // TODO: Make better: lock for each path type properly (source vs target)
-
-    // We lock and unlock frequently because SPI SD card devices share
-    // the lock with the display. We don't want to lock the display for very long.
-
-    auto app_parent_path = getInstallPath();
-    TT_LOG_I(TAG, "Installing app %s to %s", path.c_str(), app_parent_path.c_str());
-
-    auto lock = file::getLock(app_parent_path)->asScopedLock();
-
-    lock.lock();
-    auto filename = file::getLastPathSegment(path);
-    const std::string app_target_path = std::format("{}/{}", app_parent_path, filename);
-    if (file::isDirectory(app_target_path) && !file::deleteRecursively(app_target_path)) {
-        TT_LOG_W(TAG, "Failed to delete %s", app_target_path.c_str());
-    }
-    lock.unlock();
-
-    lock.lock();
-    if (!file::findOrCreateDirectory(app_target_path, 0777)) {
-        TT_LOG_I(TAG, "Failed to create directory %s", app_target_path.c_str());
-        return false;
-    }
-    lock.unlock();
-
-    lock.lock();
-    TT_LOG_I(TAG, "Extracting app from %s to %s", path.c_str(), app_target_path.c_str());
-    if (!untar(path, app_target_path)) {
-        TT_LOG_E(TAG, "Failed to extract");
-        return false;
-    }
-    lock.unlock();
-
-    lock.lock();
-    auto manifest_path = app_target_path + "/manifest.properties";
-    if (!file::isFile(manifest_path)) {
-        TT_LOG_E(TAG, "Manifest not found at %s", manifest_path.c_str());
-        return false;
-    }
-    lock.unlock();
-
-    lock.lock();
-    std::map<std::string, std::string> properties;
-    if (!file::loadPropertiesFile(manifest_path, properties)) {
-        TT_LOG_E(TAG, "Failed to load manifest at %s", manifest_path.c_str());
-        return false;
-    }
-    lock.unlock();
-
-    auto app_id_iterator = properties.find("[app]id");
-    if (app_id_iterator == properties.end()) {
-        TT_LOG_E(TAG, "Failed to find app id in manifest");
-        return false;
-    }
-
-    lock.lock();
-    const std::string renamed_target_path = std::format("{}/{}", app_parent_path, app_id_iterator->second);
-    if (file::isDirectory(renamed_target_path)) {
-        if (!file::deleteRecursively(renamed_target_path)) {
-            TT_LOG_W(TAG, "Failed to delete existing installation at %s", renamed_target_path.c_str());
-            return false;
-        }
-    }
-    lock.unlock();
-
-    lock.lock();
-    if (rename(app_target_path.c_str(), renamed_target_path.c_str()) != 0) {
-        TT_LOG_E(TAG, "Failed to rename %s to %s", app_target_path.c_str(), app_id_iterator->second.c_str());
-        return false;
-    }
-    lock.unlock();
-
-    return true;
-}
-
-} // namespace

Tactility/Source/file/PropertiesFile.cpp

@@ -22,24 +22,19 @@ bool loadPropertiesFile(const std::string& filePath, std::function<void(const st
     return file::withLock<bool>(filePath, [&filePath, &callback] {
         TT_LOG_I(TAG, "Reading properties file %s", filePath.c_str());
         uint16_t line_count = 0;
-        std::string key_prefix = "";
+        return readLines(filePath, true, [&line_count, &filePath, &callback](const std::string& line) {
-        return readLines(filePath, true, [&key_prefix, &line_count, &filePath, &callback](const std::string& line) {
             line_count++;
             std::string key, value;
             auto trimmed_line = string::trim(line, " \t");
             if (!trimmed_line.starts_with("#")) {
-                if (trimmed_line.starts_with("[")) {
-                    key_prefix = trimmed_line;
-                } else {
                 if (getKeyValuePair(trimmed_line, key, value)) {
-                       std::string trimmed_key = key_prefix + string::trim(key, " \t");
+                    std::string trimmed_key = string::trim(key, " \t");
                     std::string trimmed_value = string::trim(value, " \t");
                     callback(trimmed_key, trimmed_value);
                 } else {
                     TT_LOG_E(TAG, "Failed to parse line %d of %s", line_count, filePath.c_str());
                 }
             }
-            }
         });
     });
 }

Tactility/Source/service/development/DevelopmentService.cpp

@@ -18,8 +18,6 @@
 #include <esp_wifi.h>
 #include <ranges>
 #include <sstream>
-#include <Tactility/Tactility.h>
-#include <Tactility/file/FileLock.h>
 
 namespace tt::service::development {
 
@@ -99,7 +97,6 @@ void DevelopmentService::startServer() {
     deviceResponse = stream.str();
 
     httpd_config_t config = HTTPD_DEFAULT_CONFIG();
-    config.stack_size = 5120;
 
     config.server_port = 6666;
     config.uri_match_fn = httpd_uri_match_wildcard;
@@ -157,8 +154,6 @@ void DevelopmentService::onNetworkDisconnected() {
 // region endpoints
 
 esp_err_t DevelopmentService::handleGetInfo(httpd_req_t* request) {
-    TT_LOG_I(TAG, "GET /device");
-
     if (httpd_resp_set_type(request, "application/json") != ESP_OK) {
         TT_LOG_W(TAG, "Failed to send header");
         return ESP_FAIL;
@@ -176,8 +171,6 @@ esp_err_t DevelopmentService::handleGetInfo(httpd_req_t* request) {
 }
 
 esp_err_t DevelopmentService::handleAppRun(httpd_req_t* request) {
-    TT_LOG_I(TAG, "POST /app/run");
-
     std::string query;
     if (!network::getQueryOrSendError(request, query)) {
         return ESP_FAIL;
@@ -213,8 +206,6 @@ esp_err_t DevelopmentService::handleAppRun(httpd_req_t* request) {
 }
 
 esp_err_t DevelopmentService::handleAppInstall(httpd_req_t* request) {
-    TT_LOG_I(TAG, "PUT /app/install");
-
     std::string boundary;
     if (!network::getMultiPartBoundaryOrSendError(request, boundary)) {
         return false;
@@ -259,19 +250,8 @@ esp_err_t DevelopmentService::handleAppInstall(httpd_req_t* request) {
     }
     content_left -= content_read;
 
-    const std::string tmp_path = app::getTempPath();
-    auto lock = file::getLock(tmp_path)->asScopedLock();
-
-    lock.lock();
-    if (!file::findOrCreateDirectory(tmp_path, 0777)) {
-        httpd_resp_send_err(request, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to save file");
-        return ESP_FAIL;
-    }
-    lock.unlock();
-
     // Write file
-    lock.lock();
+    auto file_path = std::format("/data/{}", filename_entry->second);
-    auto file_path = std::format("{}/{}", tmp_path, filename_entry->second);
     auto* file = fopen(file_path.c_str(), "wb");
     auto file_bytes_written = fwrite(buffer.get(), 1, file_size, file);
     fclose(file);
@@ -279,8 +259,6 @@ esp_err_t DevelopmentService::handleAppInstall(httpd_req_t* request) {
         httpd_resp_send_err(request, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to save file");
         return ESP_FAIL;
     }
-    lock.unlock();
-
 
     // Read and verify part
     if (!network::readAndDiscardOrSendError(request, part_after_file)) {
@@ -292,21 +270,9 @@ esp_err_t DevelopmentService::handleAppInstall(httpd_req_t* request) {
         TT_LOG_W(TAG, "We have more bytes at the end of the request parsing?!");
     }
 
-    if (!app::install(file_path)) {
-        httpd_resp_send_err(request, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to install");
-        return ESP_FAIL;
-    }
-
-    lock.lock();
-    if (remove(file_path.c_str()) != 0) {
-        TT_LOG_W(TAG, "Failed to delete %s", file_path.c_str());
-    }
-    lock.unlock();
-
     TT_LOG_I(TAG, "[200] /app/install -> %s", file_path.c_str());
 
     httpd_resp_send(request, nullptr, 0);
-
     return ESP_OK;
 }
 

TactilityCore/Include/Tactility/file/File.h

@@ -67,11 +67,7 @@ bool writeString(const std::string& filepath, const std::string& content);
  * @param[in] mode the mode to use when creating directories
  * @return true when the specified path was found, or otherwise creates the directories recursively with the specified mode.
  */
-bool findOrCreateDirectory(const std::string& path, mode_t mode);
+bool findOrCreateDirectory(std::string path, mode_t mode);
-
-bool findOrCreateParentDirectory(const std::string& path, mode_t mode);
-
-bool deleteRecursively(const std::string& path);
 
 /**
  * Concatenate a child path with a parent path, ensuring proper slash inbetween
@@ -81,8 +77,6 @@ bool deleteRecursively(const std::string& path);
  */
 std::string getChildPath(const std::string& basePath, const std::string& childPath);
 
-std::string getLastPathSegment(const std::string& path);
-
 typedef int (*ScandirFilter)(const dirent*);
 
 typedef bool (*ScandirSort)(const dirent&, const dirent&);
@@ -112,8 +106,8 @@ bool isDirectory(const std::string& path);
 int scandir(
     const std::string& path,
     std::vector<dirent>& outList,
-    ScandirFilter _Nullable filter = nullptr,
+    ScandirFilter _Nullable filter,
-    ScandirSort _Nullable sort = nullptr
+    ScandirSort _Nullable sort
 );
 
 bool readLines(const std::string& filePath, bool stripNewLine, std::function<void(const char* line)> callback);

TactilityCore/Source/file/File.cpp

@@ -3,7 +3,6 @@
 #include <cstring>
 #include <fstream>
 #include <unistd.h>
-#include <Tactility/StringUtils.h>
 
 namespace tt::hal::sdcard {
 class SdCardDevice;
@@ -51,7 +50,7 @@ int scandir(
 
     dirent* current_entry;
     while ((current_entry = readdir(dir)) != nullptr) {
-        if (filterMethod == nullptr || filterMethod(current_entry) == 0) {
+        if (filterMethod(current_entry) == 0) {
             outList.push_back(*current_entry);
         }
     }
@@ -185,16 +184,7 @@ static bool findOrCreateDirectoryInternal(std::string path, mode_t mode) {
     return true;
 }
 
-std::string getLastPathSegment(const std::string& path) {
+bool findOrCreateDirectory(std::string path, mode_t mode) {
-    auto index = path.find_last_of('/');
-    if (index != std::string::npos) {
-        return path.substr(index + 1);
-    } else {
-        return "";
-    }
-}
-
-bool findOrCreateDirectory(const std::string& path, mode_t mode) {
     if (path.empty()) {
         return true;
     }
@@ -223,45 +213,6 @@ bool findOrCreateDirectory(const std::string& path, mode_t mode) {
     return true;
 }
 
-bool findOrCreateParentDirectory(const std::string& path, mode_t mode) {
-    std::string parent;
-    if (!string::getPathParent(path, parent)) {
-        return false;
-    }
-    return findOrCreateDirectory(parent, mode);
-}
-
-bool deleteRecursively(const std::string& path) {
-    if (path.empty()) {
-        return true;
-    }
-
-    if (isDirectory(path)) {
-        std::vector<dirent> entries;
-        if (scandir(path, entries) < 0) {
-            TT_LOG_E(TAG, "Failed to scan directory %s", path.c_str());
-            return false;
-        }
-        for (const auto& entry : entries) {
-            auto child_path = path + "/" + entry.d_name;
-            if (!deleteRecursively(child_path)) {
-                return false;
-            }
-        }
-        TT_LOG_I(TAG, "Deleting %s", path.c_str());
-        return rmdir(path.c_str()) == 0;
-    } else if (isFile(path)) {
-        TT_LOG_I(TAG, "Deleting %s", path.c_str());
-        return remove(path.c_str()) == 0;
-    } else if (path == "/" || path == "." || path == "..") {
-        // No-op
-        return true;
-    } else {
-        TT_LOG_E(TAG, "Failed to delete \"%s\": unknown type", path.c_str());
-        return false;
-    }
-}
-
 bool isFile(const std::string& path) {
     return access(path.c_str(), F_OK) == 0;
 }