App hub and more (#383)

- Added `AppHub` app
- Added `AppHubDetails` app
- Added `cJSON` dependency
- Renamed `AppSim` module to `FirmwareSim`
- Added extra `tt::app::alertdialg::start()`
- Renamed `addApp()`, `removeApp()`, `findAppById()` and `getApps()` to `addAppManifest()`, `removeAppManifest()`, `findAppManifestById()` and `getAppManifests()`
- Added `tt::lvgl::toolbar_clear_actions()`
- Added `tt::network::EspHttpClient` as a thread-safe wrapper around `esp_http_client`
- Added `tt::network::http::download()` to download files
- Added `tt::network::ntp::isSynced()`
- When time is synced, the timestamp is stored in NVS flash. On boot, it is restored. This helps SSL connections when doing a quick reset: when WiFi reconnects, the user doesn't have to wait for NTP sync before SSL works.
- Added `tt::json::Reader` as a `cJSON` wrapper
- Added `int64_t` support for `Preferences`
- Added `int64_t` support for `Bundle`
- Added dependencies: `cJSON`, `esp-tls`
- When time is synced via NTP, disable time sync.
- Added docs to 'tt::file::` functions
- Added `tt::string::join()` that works with `std::vector<const char*>`
- Fixed `tt::file::getLastPathSegment()` for the scenario when a path was passed with only a single segment
- Set `CONFIG_ESP_MAIN_TASK_STACK_SIZE=5120` (from about 3k) for all boards
- Set `CONFIG_MBEDTLS_SSL_PROTO_TLS1_3=y` for all boards

Tactility/Include/Tactility/Preferences.h

@@ -24,14 +24,17 @@ public:
 
     bool hasBool(const std::string& key) const;
     bool hasInt32(const std::string& key) const;
+    bool hasInt64(const std::string& key) const;
     bool hasString(const std::string& key) const;
 
     bool optBool(const std::string& key, bool& out) const;
     bool optInt32(const std::string& key, int32_t& out) const;
+    bool optInt64(const std::string& key, int64_t& out) const;
     bool optString(const std::string& key, std::string& out) const;
 
     void putBool(const std::string& key, bool value);
     void putInt32(const std::string& key, int32_t value);
+    void putInt64(const std::string& key, int64_t value);
     void putString(const std::string& key, const std::string& value);
 };
 

Tactility/Include/Tactility/app/AppRegistration.h

@@ -9,18 +9,18 @@ namespace tt::app {
 struct AppManifest;
 
 /** Register an application with its manifest */
-void addApp(const AppManifest& manifest);
+void addAppManifest(const AppManifest& manifest);
 
 /** Remove an app from the registry */
-bool removeApp(const std::string& id);
+bool removeAppManifest(const std::string& id);
 
 /** Find an application manifest by its id
  * @param[in] id the manifest id
  * @return the application manifest if it was found
  */
-_Nullable std::shared_ptr<AppManifest> findAppById(const std::string& id);
+_Nullable std::shared_ptr<AppManifest> findAppManifestById(const std::string& id);
 
 /** @return a list of all registered apps. This includes user and system apps. */
-std::vector<std::shared_ptr<AppManifest>> getApps();
+std::vector<std::shared_ptr<AppManifest>> getAppManifests();
 
 } // namespace

Tactility/Include/Tactility/app/alertdialog/AlertDialog.h

@@ -22,6 +22,14 @@ namespace tt::app::alertdialog {
  * @return the launch id
  */
 LaunchId start(const std::string& title, const std::string& message, const std::vector<std::string>& buttonLabels);
+/**
+ * Show a dialog with the provided title, message and 0, 1 or more buttons.
+ * @param[in] title the title to show in the toolbar
+ * @param[in] message the message to display
+ * @param[in] buttonLabels the buttons to show
+ * @return the launch id
+ */
+LaunchId start(const std::string& title, const std::string& message, const std::vector<const char*>& buttonLabels);
 
 /**
  * Show a dialog with the provided title, message and an OK button

Tactility/Include/Tactility/lvgl/Toolbar.h

@@ -6,7 +6,6 @@
 #include <lvgl.h>
 
 namespace tt::lvgl {
-
 #define TOOLBAR_ACTION_LIMIT 4
 
 /** Create a toolbar widget that shows the app name as title */
@@ -60,4 +59,10 @@ lv_obj_t* toolbar_add_switch_action(lv_obj_t* obj);
  */
 lv_obj_t* toolbar_add_spinner_action(lv_obj_t* obj);
 
+/**
+ * Remove all actions from the toolbar
+ * @param[in] obj the toolbar instance
+ */
+void toolbar_clear_actions(lv_obj_t* obj);
+
 } // namespace

Tactility/Include/Tactility/network/EspHttpClient.h

@@ -0,0 +1,104 @@
+#pragma once
+
+#ifdef ESP_PLATFORM
+
+#include <esp_http_client.h>
+
+namespace tt::network {
+
+class EspHttpClient {
+
+    static constexpr auto* TAG = "EspHttpClient";
+
+    std::unique_ptr<esp_http_client_config_t> config = nullptr;
+    esp_http_client_handle_t client;
+    bool isOpen = false;
+
+public:
+
+    ~EspHttpClient() {
+        if (isOpen) {
+            esp_http_client_close(client);
+        }
+
+        if (client != nullptr) {
+            esp_http_client_cleanup(client);
+        }
+    }
+
+    bool init(std::unique_ptr<esp_http_client_config_t> inConfig) {
+        TT_LOG_I(TAG, "init(%s)", inConfig->url);
+        assert(this->config == nullptr);
+        config = std::move(inConfig);
+        client = esp_http_client_init(config.get());
+        return client != nullptr;
+    }
+
+    bool open() {
+        assert(client != nullptr);
+        TT_LOG_I(TAG, "open()");
+        auto result = esp_http_client_open(client, 0);
+
+        if (result != ESP_OK) {
+            TT_LOG_E(TAG, "open() failed: %s", esp_err_to_name(result));
+            return false;
+        }
+
+        isOpen = true;
+        return true;
+    }
+
+    bool fetchHeaders() const {
+        assert(client != nullptr);
+        TT_LOG_I(TAG, "fetchHeaders()");
+        return esp_http_client_fetch_headers(client) >= 0;
+    }
+
+    bool isStatusCodeOk() const {
+        assert(client != nullptr);
+        const auto status_code = getStatusCode();
+        return status_code >= 200 && status_code < 300;
+    }
+
+    int getStatusCode() const {
+        assert(client != nullptr);
+        const auto status_code = esp_http_client_get_status_code(client);
+        TT_LOG_I(TAG, "Status code %d", status_code);
+        return status_code;
+    }
+
+    int getContentLength() const {
+        assert(client != nullptr);
+        return esp_http_client_get_content_length(client);
+    }
+
+    int read(char* bytes, int size) const {
+        assert(client != nullptr);
+        TT_LOG_I(TAG, "read(%d)", size);
+        return esp_http_client_read(client, bytes, size);
+    }
+
+    int readResponse(char* bytes, int size) const {
+        assert(client != nullptr);
+        TT_LOG_I(TAG, "readResponse(%d)", size);
+        return esp_http_client_read_response(client, bytes, size);
+    }
+
+    bool close() {
+        assert(client != nullptr);
+        TT_LOG_I(TAG, "close()");
+        return esp_http_client_close(client) == ESP_OK;
+    }
+
+    bool cleanup() {
+        assert(client != nullptr);
+        TT_LOG_I(TAG, "cleanup()");
+        const auto result = esp_http_client_cleanup(client);
+        client = nullptr;
+        return result == ESP_OK;
+    }
+};
+
+}
+
+#endif

Tactility/Include/Tactility/network/Http.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <string>
+
+namespace tt::network::http {
+
+void download(
+    const std::string& url,
+    const std::string& certFilePath,
+    const std::string &downloadFilePath,
+    std::function<void()> onSuccess,
+    std::function<void(const char* errorMessage)> onError
+);
+
+}

Tactility/Include/Tactility/network/Ntp.h

@@ -0,0 +1,7 @@
+#pragma once
+
+namespace tt::network::ntp {
+
+bool isSynced();
+
+}