diff --git a/CMakeLists.txt b/CMakeLists.txt index 7e37634eb..ff2a8f874 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -41,6 +41,7 @@ if (DEFINED ENV{ESP_IDF_VERSION}) "Modules" "Platforms/platform-esp32" "TactilityKernel" + "TactilityKernelCpp" "Tactility" "TactilityC" "TactilityFreeRtos" @@ -89,6 +90,7 @@ if (NOT DEFINED ENV{ESP_IDF_VERSION}) add_subdirectory(Tactility) add_subdirectory(TactilityFreeRtos) add_subdirectory(TactilityKernel) + add_subdirectory(TactilityKernelCpp) add_subdirectory(Platforms/platform-posix) add_subdirectory(Devices/simulator) add_subdirectory(Libraries/cJSON) diff --git a/Modules/app-module/include/app/metadata.h b/Modules/app-module/include/app/metadata.h index 55b1f0819..ae0a16db4 100644 --- a/Modules/app-module/include/app/metadata.h +++ b/Modules/app-module/include/app/metadata.h @@ -13,7 +13,6 @@ extern "C" { #define APP_METADATA_APP_ID_LENGTH 32 #define APP_METADATA_APP_NAME_LENGTH 32 #define APP_METADATA_APP_VERSION_NAME_LENGTH 16 -#define APP_METADATA_REQUIRES_DEVICE_ARCH_LENGTH 32 #define APP_METADATA_REQUIRES_DEVICE_ID_LENGTH 64 struct AppMetadata { @@ -45,13 +44,6 @@ struct AppMetadata { /** The technical version (must be incremented with new releases of the app) */ uint64_t app_version_code; - /** - * Comma-separated list of MCU architectures the app is restricted to (e.g. "esp32s3,esp32p4"), - * matching ESP-IDF target names. Empty means unrestricted. - * Must be NULL-terminated. - */ - char requires_device_arch[APP_METADATA_REQUIRES_DEVICE_ARCH_LENGTH + 1]; - /** * Comma-separated list of device ids the app is restricted to (e.g. "m5stack-tab5"), matching * the folder names under Devices/. Empty means unrestricted. diff --git a/Modules/app-module/private/app/private/app_metadata_parsing_internal.h b/Modules/app-module/private/app/private/app_metadata_parsing_internal.h index 1279ab9a4..9259e5691 100644 --- a/Modules/app-module/private/app/private/app_metadata_parsing_internal.h +++ b/Modules/app-module/private/app/private/app_metadata_parsing_internal.h @@ -18,9 +18,6 @@ bool app_metadata_is_valid_name(const std::string& name); bool app_metadata_is_valid_version_name(const std::string& version); bool app_metadata_is_valid_version_code(const std::string& version); -/** Validates a comma-separated list of MCU architecture names (alphanumeric items only). */ -bool app_metadata_is_valid_device_arch_list(const std::string& value); - /** Validates a comma-separated list of device ids (alphanumeric + '-' items, matching Devices/ folder names). */ bool app_metadata_is_valid_device_id_list(const std::string& value); diff --git a/Modules/app-module/source/app_metadata_parsing.cpp b/Modules/app-module/source/app_metadata_parsing.cpp index 6da82a3ed..7ea7afa0d 100644 --- a/Modules/app-module/source/app_metadata_parsing.cpp +++ b/Modules/app-module/source/app_metadata_parsing.cpp @@ -150,12 +150,6 @@ bool app_metadata_is_valid_version_code(const std::string& version) { }); } -bool app_metadata_is_valid_device_arch_list(const std::string& value) { - return validate_csv_list(value, [](char c) { - return std::isalnum(static_cast(c)) != 0; - }); -} - bool app_metadata_is_valid_device_id_list(const std::string& value) { return validate_csv_list(value, [](char c) { return std::isalnum(static_cast(c)) != 0 || c == '-'; @@ -173,8 +167,8 @@ bool app_metadata_copy_bounded(char* dest, size_t dest_size, const std::string& error_t app_metadata_parse(const char* path, struct AppMetadata* out_metadata) { LOG_I(TAG, "Parsing manifest %s", path); - // Both requires.* fields are optional in V2 and unwritten by V1; zeroing here (rather than - // relying on the caller) guarantees they read back as empty ("unrestricted") either way. + // requires_device_id is optional in V2 and unwritten by V1; zeroing here (rather than relying + // on the caller) guarantees it reads back as empty ("unrestricted") either way. *out_metadata = {}; std::map properties; diff --git a/Modules/app-module/source/app_metadata_parsing_v2.cpp b/Modules/app-module/source/app_metadata_parsing_v2.cpp index 9a08003b6..b6baaa0ab 100644 --- a/Modules/app-module/source/app_metadata_parsing_v2.cpp +++ b/Modules/app-module/source/app_metadata_parsing_v2.cpp @@ -99,20 +99,7 @@ bool app_metadata_parse_v2(const std::map& properties, return false; } - // requires (optional; if present, must be a non-empty comma-separated list) - - auto device_arch_iterator = properties.find("requires.device.arch"); - if (device_arch_iterator != properties.end()) { - const std::string& device_arch = device_arch_iterator->second; - if (!app_metadata_is_valid_device_arch_list(device_arch)) { - LOG_E(TAG, "Invalid requires.device.arch"); - return false; - } - if (!app_metadata_copy_bounded(out_metadata.requires_device_arch, sizeof(out_metadata.requires_device_arch), device_arch)) { - LOG_E(TAG, "requires.device.arch too long"); - return false; - } - } + // requires.device.id (optional; if present, must be a non-empty comma-separated list) auto device_id_iterator = properties.find("requires.device.id"); if (device_id_iterator != properties.end()) { diff --git a/Tactility/CMakeLists.txt b/Tactility/CMakeLists.txt index 3de858ac9..241713e02 100644 --- a/Tactility/CMakeLists.txt +++ b/Tactility/CMakeLists.txt @@ -6,6 +6,7 @@ file(GLOB_RECURSE SOURCE_FILES Source/*.c*) list(APPEND REQUIRES_LIST TactilityKernel + TactilityKernelCpp TactilityFreeRtos lvgl-module lvgl-window-manager-module diff --git a/Tactility/Private/Tactility/app/apphub/AppHubEntry.h b/Tactility/Private/Tactility/app/apphub/AppHubEntry.h index 4ec80e1c2..e498d52c6 100644 --- a/Tactility/Private/Tactility/app/apphub/AppHubEntry.h +++ b/Tactility/Private/Tactility/app/apphub/AppHubEntry.h @@ -1,5 +1,7 @@ #pragma once +#include + #include #include @@ -16,6 +18,10 @@ struct AppHubEntry { std::string file; }; -bool parseJson(const std::string& filePath, std::vector& entries); +// The top-level entries buffer prefers PSRAM/SPIRAM via OptExternalAllocator; individual +// AppHubEntry string/vector members still use the default (internal-RAM) allocator. +using AppHubEntryList = std::vector>; + +bool parseJson(const std::string& filePath, AppHubEntryList& entries); } \ No newline at end of file diff --git a/Tactility/Source/app/apphub/AppHubApp.cpp b/Tactility/Source/app/apphub/AppHubApp.cpp index dd9945edd..1891aa29c 100644 --- a/Tactility/Source/app/apphub/AppHubApp.cpp +++ b/Tactility/Source/app/apphub/AppHubApp.cpp @@ -36,7 +36,7 @@ struct Context { lv_obj_t* contentWrapper = nullptr; lv_obj_t* refreshButton = nullptr; std::string cachedAppsJsonFile = std::format("{}/app_hub.json", getTempPath()); - std::vector entries; + AppHubEntryList entries; Mutex mutex; }; @@ -89,6 +89,19 @@ void showApps(Context* ctx) { lv_obj_clean(ctx->contentWrapper); ctx->mutex.lock(); if (parseJson(ctx->cachedAppsJsonFile, ctx->entries)) { + // An empty targetPlatforms list means the entry runs everywhere; otherwise it must name + // this build's own target to be installable here. The simulator isn't a real MCU target, + // so it has nothing to match against and skips this filter entirely. + std::erase_if(ctx->entries, [](const AppHubEntry& entry) { +#ifdef ESP_PLATFORM + return !entry.targetPlatforms.empty() && + std::ranges::find(entry.targetPlatforms, CONFIG_IDF_TARGET) == entry.targetPlatforms.end(); +#else + (void)entry; + return false; +#endif + }); + std::ranges::sort(ctx->entries, [](auto left, auto right) { return left.appName < right.appName; }); diff --git a/Tactility/Source/app/apphub/AppHubEntry.cpp b/Tactility/Source/app/apphub/AppHubEntry.cpp index a8dce05d4..441dbe6bb 100644 --- a/Tactility/Source/app/apphub/AppHubEntry.cpp +++ b/Tactility/Source/app/apphub/AppHubEntry.cpp @@ -20,7 +20,7 @@ static bool parseEntry(const cJSON* object, AppHubEntry& entry) { reader.readStringArray("targetPlatforms", entry.targetPlatforms); } -bool parseJson(const std::string& filePath, std::vector& entries) { +bool parseJson(const std::string& filePath, AppHubEntryList& entries) { file::FileMutexGuard guard(filePath); auto data = file::readString(filePath); diff --git a/TactilityKernelCpp/CMakeLists.txt b/TactilityKernelCpp/CMakeLists.txt new file mode 100644 index 000000000..94d6d49bd --- /dev/null +++ b/TactilityKernelCpp/CMakeLists.txt @@ -0,0 +1,21 @@ +cmake_minimum_required(VERSION 3.20) + +if (DEFINED ENV{ESP_IDF_VERSION}) + + idf_component_register( + INCLUDE_DIRS "Include/" + REQUIRES TactilityKernel + ) + +else() + + add_library(TactilityKernelCpp INTERFACE) + + target_include_directories(TactilityKernelCpp + INTERFACE Include/ + ) + + target_link_libraries(TactilityKernelCpp + INTERFACE TactilityKernel + ) +endif() diff --git a/TactilityKernelCpp/Include/TactilityCpp/Allocator.h b/TactilityKernelCpp/Include/TactilityCpp/Allocator.h new file mode 100644 index 000000000..52fbb5b7f --- /dev/null +++ b/TactilityKernelCpp/Include/TactilityCpp/Allocator.h @@ -0,0 +1,46 @@ +// SPDX-License-Identifier: Apache-2.0 +#pragma once + +#include + +#include +#include +#include + +namespace tt { + +/** Allocator backed by tactility/memory.h's memory_alloc_with_policy(), with Required/Desired as + * its required/desired MemoryCapability flags (bitwise-OR'd, e.g. MEMORY_CAPABILITY_EXTERNAL). */ +template +struct Allocator { + using value_type = T; + + // libstdc++'s default rebind_alloc only pattern-matches allocator templates whose parameters + // are all types, which Required/Desired (non-type) breaks; spelling it out here restores it. + template struct rebind { using other = Allocator; }; + + Allocator() noexcept = default; + template constexpr Allocator(const Allocator&) noexcept {} + + T* allocate(std::size_t n) { + const MemoryPolicy policy { .required = Required, .desired = Desired, .alignment = alignof(T) }; + void* ptr = memory_alloc_with_policy(n * sizeof(T), &policy); + if (ptr == nullptr) { + std::abort(); // Exceptions are disabled project-wide, so OOM can't be signalled via std::bad_alloc. + } + return static_cast(ptr); + } + + void deallocate(T* ptr, std::size_t) noexcept { + memory_free(ptr); + } +}; + +template +bool operator==(const Allocator&, const Allocator&) noexcept { return true; } + +/** Prefers external memory, falling back to internal RAM when unavailable. */ +template +using OptExternalAllocator = Allocator; + +} // namespace tt diff --git a/TactilityKernelCpp/LICENSE-Apache-2.0.md b/TactilityKernelCpp/LICENSE-Apache-2.0.md new file mode 100644 index 000000000..f5f4b8b5e --- /dev/null +++ b/TactilityKernelCpp/LICENSE-Apache-2.0.md @@ -0,0 +1,195 @@ +Apache License +============== + +_Version 2.0, January 2004_ +_<>_ + +### Terms and Conditions for use, reproduction, and distribution + +#### 1. Definitions + +“License” shall mean the terms and conditions for use, reproduction, and +distribution as defined by Sections 1 through 9 of this document. + +“Licensor” shall mean the copyright owner or entity authorized by the copyright +owner that is granting the License. + +“Legal Entity” shall mean the union of the acting entity and all other entities +that control, are controlled by, or are under common control with that entity. +For the purposes of this definition, “control” means **(i)** the power, direct or +indirect, to cause the direction or management of such entity, whether by +contract or otherwise, or **(ii)** ownership of fifty percent (50%) or more of the +outstanding shares, or **(iii)** beneficial ownership of such entity. + +“You” (or “Your”) shall mean an individual or Legal Entity exercising +permissions granted by this License. + +“Source” form shall mean the preferred form for making modifications, including +but not limited to software source code, documentation source, and configuration +files. + +“Object” form shall mean any form resulting from mechanical transformation or +translation of a Source form, including but not limited to compiled object code, +generated documentation, and conversions to other media types. + +“Work” shall mean the work of authorship, whether in Source or Object form, made +available under the License, as indicated by a copyright notice that is included +in or attached to the work (an example is provided in the Appendix below). + +“Derivative Works” shall mean any work, whether in Source or Object form, that +is based on (or derived from) the Work and for which the editorial revisions, +annotations, elaborations, or other modifications represent, as a whole, an +original work of authorship. For the purposes of this License, Derivative Works +shall not include works that remain separable from, or merely link (or bind by +name) to the interfaces of, the Work and Derivative Works thereof. + +“Contribution” shall mean any work of authorship, including the original version +of the Work and any modifications or additions to that Work or Derivative Works +thereof, that is intentionally submitted to Licensor for inclusion in the Work +by the copyright owner or by an individual or Legal Entity authorized to submit +on behalf of the copyright owner. For the purposes of this definition, +“submitted” means any form of electronic, verbal, or written communication sent +to the Licensor or its representatives, including but not limited to +communication on electronic mailing lists, source code control systems, and +issue tracking systems that are managed by, or on behalf of, the Licensor for +the purpose of discussing and improving the Work, but excluding communication +that is conspicuously marked or otherwise designated in writing by the copyright +owner as “Not a Contribution.” + +“Contributor” shall mean Licensor and any individual or Legal Entity on behalf +of whom a Contribution has been received by Licensor and subsequently +incorporated within the Work. + +#### 2. Grant of Copyright License + +Subject to the terms and conditions of this License, each Contributor hereby +grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, +irrevocable copyright license to reproduce, prepare Derivative Works of, +publicly display, publicly perform, sublicense, and distribute the Work and such +Derivative Works in Source or Object form. + +#### 3. Grant of Patent License + +Subject to the terms and conditions of this License, each Contributor hereby +grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, +irrevocable (except as stated in this section) patent license to make, have +made, use, offer to sell, sell, import, and otherwise transfer the Work, where +such license applies only to those patent claims licensable by such Contributor +that are necessarily infringed by their Contribution(s) alone or by combination +of their Contribution(s) with the Work to which such Contribution(s) was +submitted. If You institute patent litigation against any entity (including a +cross-claim or counterclaim in a lawsuit) alleging that the Work or a +Contribution incorporated within the Work constitutes direct or contributory +patent infringement, then any patent licenses granted to You under this License +for that Work shall terminate as of the date such litigation is filed. + +#### 4. Redistribution + +You may reproduce and distribute copies of the Work or Derivative Works thereof +in any medium, with or without modifications, and in Source or Object form, +provided that You meet the following conditions: + +* **(a)** You must give any other recipients of the Work or Derivative Works a copy of +this License; and +* **(b)** You must cause any modified files to carry prominent notices stating that You +changed the files; and +* **(c)** You must retain, in the Source form of any Derivative Works that You distribute, +all copyright, patent, trademark, and attribution notices from the Source form +of the Work, excluding those notices that do not pertain to any part of the +Derivative Works; and +* **(d)** If the Work includes a “NOTICE” text file as part of its distribution, then any +Derivative Works that You distribute must include a readable copy of the +attribution notices contained within such NOTICE file, excluding those notices +that do not pertain to any part of the Derivative Works, in at least one of the +following places: within a NOTICE text file distributed as part of the +Derivative Works; within the Source form or documentation, if provided along +with the Derivative Works; or, within a display generated by the Derivative +Works, if and wherever such third-party notices normally appear. The contents of +the NOTICE file are for informational purposes only and do not modify the +License. You may add Your own attribution notices within Derivative Works that +You distribute, alongside or as an addendum to the NOTICE text from the Work, +provided that such additional attribution notices cannot be construed as +modifying the License. + +You may add Your own copyright statement to Your modifications and may provide +additional or different license terms and conditions for use, reproduction, or +distribution of Your modifications, or for any such Derivative Works as a whole, +provided Your use, reproduction, and distribution of the Work otherwise complies +with the conditions stated in this License. + +#### 5. Submission of Contributions + +Unless You explicitly state otherwise, any Contribution intentionally submitted +for inclusion in the Work by You to the Licensor shall be under the terms and +conditions of this License, without any additional terms or conditions. +Notwithstanding the above, nothing herein shall supersede or modify the terms of +any separate license agreement you may have executed with Licensor regarding +such Contributions. + +#### 6. Trademarks + +This License does not grant permission to use the trade names, trademarks, +service marks, or product names of the Licensor, except as required for +reasonable and customary use in describing the origin of the Work and +reproducing the content of the NOTICE file. + +#### 7. Disclaimer of Warranty + +Unless required by applicable law or agreed to in writing, Licensor provides the +Work (and each Contributor provides its Contributions) on an “AS IS” BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, +including, without limitation, any warranties or conditions of TITLE, +NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are +solely responsible for determining the appropriateness of using or +redistributing the Work and assume any risks associated with Your exercise of +permissions under this License. + +#### 8. Limitation of Liability + +In no event and under no legal theory, whether in tort (including negligence), +contract, or otherwise, unless required by applicable law (such as deliberate +and grossly negligent acts) or agreed to in writing, shall any Contributor be +liable to You for damages, including any direct, indirect, special, incidental, +or consequential damages of any character arising as a result of this License or +out of the use or inability to use the Work (including but not limited to +damages for loss of goodwill, work stoppage, computer failure or malfunction, or +any and all other commercial damages or losses), even if such Contributor has +been advised of the possibility of such damages. + +#### 9. Accepting Warranty or Additional Liability + +While redistributing the Work or Derivative Works thereof, You may choose to +offer, and charge a fee for, acceptance of support, warranty, indemnity, or +other liability obligations and/or rights consistent with this License. However, +in accepting such obligations, You may act only on Your own behalf and on Your +sole responsibility, not on behalf of any other Contributor, and only if You +agree to indemnify, defend, and hold each Contributor harmless for any liability +incurred by, or claims asserted against, such Contributor by reason of your +accepting any such warranty or additional liability. + +_END OF TERMS AND CONDITIONS_ + +### APPENDIX: How to apply the Apache License to your work + +To apply the Apache License to your work, attach the following boilerplate +notice, with the fields enclosed by brackets `[]` replaced with your own +identifying information. (Don't include the brackets!) The text should be +enclosed in the appropriate comment syntax for the file format. We also +recommend that a file or class name and description of purpose be included on +the same “printed page” as the copyright notice for easier identification within +third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + diff --git a/TactilityKernelCpp/README.md b/TactilityKernelCpp/README.md new file mode 100644 index 000000000..94cf48508 --- /dev/null +++ b/TactilityKernelCpp/README.md @@ -0,0 +1,7 @@ +# TactilityKernelCpp + +Headers-only C++ wrappers around TactilityKernel's C API. + +## License + +[Apache License 2.0](LICENSE-Apache-2.0.md)