Make namespaces more consistent (#92)

Tactility/Source/app/wificonnect/WifiConnect.cpp

@@ -0,0 +1,146 @@
+#include "WifiConnect.h"
+
+#include "app/App.h"
+#include "TactilityCore.h"
+#include "WifiConnectStateUpdating.h"
+#include "service/loader/Loader.h"
+#include "service/wifi/Wifi.h"
+#include "lvgl/LvglSync.h"
+
+namespace tt::app::wificonnect {
+
+#define TAG "wifi_connect"
+
+// Forward declarations
+static void event_callback(const void* message, void* context);
+
+static void on_connect(const service::wifi::settings::WifiApSettings* ap_settings, bool remember, TT_UNUSED void* parameter) {
+    auto* wifi = static_cast<WifiConnect*>(parameter);
+    state_set_ap_settings(wifi, ap_settings);
+    state_set_connecting(wifi, true);
+    service::wifi::connect(ap_settings, remember);
+}
+
+static WifiConnect* wifi_connect_alloc() {
+    auto* wifi = static_cast<WifiConnect*>(malloc(sizeof(WifiConnect)));
+
+    PubSub* wifi_pubsub = service::wifi::get_pubsub();
+    wifi->wifi_subscription = tt_pubsub_subscribe(wifi_pubsub, &event_callback, wifi);
+    wifi->mutex = tt_mutex_alloc(MutexTypeNormal);
+    wifi->state = (WifiConnectState) {
+        .settings = {
+            .ssid = { 0 },
+            .password = { 0 },
+            .auto_connect = false,
+        },
+        .connection_error = false,
+        .is_connecting = false
+    };
+    wifi->bindings = (WifiConnectBindings) {
+        .on_connect_ssid = &on_connect,
+        .on_connect_ssid_context = wifi,
+    };
+    wifi->view_enabled = false;
+
+    return wifi;
+}
+
+static void wifi_connect_free(WifiConnect* wifi) {
+    PubSub* wifi_pubsub = service::wifi::get_pubsub();
+    tt_pubsub_unsubscribe(wifi_pubsub, wifi->wifi_subscription);
+    tt_mutex_free(wifi->mutex);
+
+    free(wifi);
+}
+
+void lock(WifiConnect* wifi) {
+    tt_assert(wifi);
+    tt_assert(wifi->mutex);
+    tt_mutex_acquire(wifi->mutex, TtWaitForever);
+}
+
+void unlock(WifiConnect* wifi) {
+    tt_assert(wifi);
+    tt_assert(wifi->mutex);
+    tt_mutex_release(wifi->mutex);
+}
+
+void request_view_update(WifiConnect* wifi) {
+    lock(wifi);
+    if (wifi->view_enabled) {
+        if (lvgl::lock(1000)) {
+            view_update(&wifi->view, &wifi->bindings, &wifi->state);
+            lvgl::unlock();
+        } else {
+            TT_LOG_E(TAG, "Failed to lock lvgl");
+        }
+    }
+    unlock(wifi);
+}
+
+static void event_callback(const void* message, void* context) {
+    auto* event = static_cast<const service::wifi::WifiEvent*>(message);
+    auto* wifi = static_cast<WifiConnect*>(context);
+    switch (event->type) {
+        case service::wifi::WifiEventTypeConnectionFailed:
+            if (wifi->state.is_connecting) {
+                state_set_connecting(wifi, false);
+                state_set_radio_error(wifi, true);
+                request_view_update(wifi);
+            }
+            break;
+        case service::wifi::WifiEventTypeConnectionSuccess:
+            if (wifi->state.is_connecting) {
+                state_set_connecting(wifi, false);
+                service::loader::stop_app();
+            }
+            break;
+        default:
+            break;
+    }
+    request_view_update(wifi);
+}
+
+static void app_show(App app, lv_obj_t* parent) {
+    auto* wifi = static_cast<WifiConnect*>(tt_app_get_data(app));
+
+    lock(wifi);
+    wifi->view_enabled = true;
+    view_create(app, wifi, parent);
+    view_update(&wifi->view, &wifi->bindings, &wifi->state);
+    unlock(wifi);
+}
+
+static void app_hide(App app) {
+    auto* wifi = static_cast<WifiConnect*>(tt_app_get_data(app));
+    // No need to lock view, as this is called from within Gui's LVGL context
+    view_destroy(&wifi->view);
+    lock(wifi);
+    wifi->view_enabled = false;
+    unlock(wifi);
+}
+
+static void app_start(App app) {
+    auto* wifi_connect = wifi_connect_alloc();
+    tt_app_set_data(app, wifi_connect);
+}
+
+static void app_stop(App app) {
+    auto* wifi = static_cast<WifiConnect*>(tt_app_get_data(app));
+    tt_assert(wifi != nullptr);
+    wifi_connect_free(wifi);
+    tt_app_set_data(app, nullptr);
+}
+
+extern const Manifest manifest = {
+    .id = "WifiConnect",
+    .name = "Wi-Fi Connect",
+    .icon = LV_SYMBOL_WIFI,
+    .type = TypeSettings,
+    .on_start = &app_start,
+    .on_stop = &app_stop,
+    .on_show = &app_show,
+    .on_hide = &app_hide
+};
+
+} // namespace

Tactility/Source/app/wificonnect/WifiConnect.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "Mutex.h"
+#include "WifiConnectBindings.h"
+#include "WifiConnectState.h"
+#include "WifiConnectView.h"
+#include "service/wifi/Wifi.h"
+
+namespace tt::app::wificonnect {
+
+typedef struct {
+    PubSubSubscription* wifi_subscription;
+    Mutex* mutex;
+    WifiConnectState state;
+    WifiConnectView view;
+    bool view_enabled;
+    WifiConnectBindings bindings;
+} WifiConnect;
+
+void lock(WifiConnect* wifi);
+
+void unlock(WifiConnect* wifi);
+
+void view_update(WifiConnect* wifi);
+
+} // namespace

Tactility/Source/app/wificonnect/WifiConnectBindings.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "service/wifi/WifiSettings.h"
+
+namespace tt::app::wificonnect {
+
+typedef void (*OnConnectSsid)(const service::wifi::settings::WifiApSettings* settings, bool store, void* context);
+
+typedef struct {
+    OnConnectSsid on_connect_ssid;
+    void* on_connect_ssid_context;
+} WifiConnectBindings;
+
+} // namespace

Tactility/Source/app/wificonnect/WifiConnectBundle.h

@@ -0,0 +1,4 @@
+#pragma once
+
+#define WIFI_CONNECT_PARAM_SSID "ssid" // String
+#define WIFI_CONNECT_PARAM_PASSWORD "password" // String

Tactility/Source/app/wificonnect/WifiConnectState.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "service/wifi/Wifi.h"
+#include "service/wifi/WifiSettings.h"
+
+namespace tt::app::wificonnect {
+
+/**
+ * View's state
+ */
+typedef struct {
+    service::wifi::settings::WifiApSettings settings;
+    bool connection_error;
+    bool is_connecting;
+} WifiConnectState;
+
+} // namespace

Tactility/Source/app/wificonnect/WifiConnectStateUpdating.cpp

@@ -0,0 +1,23 @@
+#include "WifiConnectStateUpdating.h"
+
+namespace tt::app::wificonnect {
+
+void state_set_radio_error(WifiConnect* wifi, bool error) {
+    lock(wifi);
+    wifi->state.connection_error = error;
+    unlock(wifi);
+}
+
+void state_set_ap_settings(WifiConnect* wifi, const service::wifi::settings::WifiApSettings* settings) {
+    lock(wifi);
+    memcpy(&(wifi->state.settings), settings, sizeof(service::wifi::settings::WifiApSettings));
+    unlock(wifi);
+}
+
+void state_set_connecting(WifiConnect* wifi, bool is_connecting) {
+    lock(wifi);
+    wifi->state.is_connecting = is_connecting;
+    unlock(wifi);
+}
+
+} // namespace

Tactility/Source/app/wificonnect/WifiConnectStateUpdating.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include "WifiConnect.h"
+
+namespace tt::app::wificonnect {
+
+void state_set_radio_error(WifiConnect* wifi, bool error);
+void state_set_ap_settings(WifiConnect* wifi, const service::wifi::settings::WifiApSettings* settings);
+void state_set_connecting(WifiConnect* wifi, bool is_connecting);
+
+} // namespace

Tactility/Source/app/wificonnect/WifiConnectView.cpp

@@ -0,0 +1,227 @@
+#include "WifiConnectView.h"
+
+#include "Log.h"
+#include "WifiConnect.h"
+#include "WifiConnectBundle.h"
+#include "WifiConnectState.h"
+#include "WifiConnectStateUpdating.h"
+#include "lvgl.h"
+#include "service/gui/Gui.h"
+#include "service/wifi/WifiSettings.h"
+#include "lvgl/Style.h"
+#include "lvgl/Toolbar.h"
+
+namespace tt::app::wificonnect {
+
+#define TAG "wifi_connect"
+
+static void view_set_loading(WifiConnectView* view, bool loading);
+
+static void reset_errors(WifiConnectView* view) {
+    lv_obj_add_flag(view->password_error, LV_OBJ_FLAG_HIDDEN);
+    lv_obj_add_flag(view->ssid_error, LV_OBJ_FLAG_HIDDEN);
+    lv_obj_add_flag(view->connection_error, LV_OBJ_FLAG_HIDDEN);
+}
+
+static void on_connect(lv_event_t* event) {
+    WifiConnect* wifi = (WifiConnect*)lv_event_get_user_data(event);
+    WifiConnectView* view = &wifi->view;
+
+    state_set_radio_error(wifi, false);
+    reset_errors(view);
+
+    const char* ssid = lv_textarea_get_text(view->ssid_textarea);
+    size_t ssid_len = strlen(ssid);
+    if (ssid_len > TT_WIFI_SSID_LIMIT) {
+        TT_LOG_E(TAG, "SSID too long");
+        lv_label_set_text(view->ssid_error, "SSID too long");
+        lv_obj_remove_flag(view->ssid_error, LV_OBJ_FLAG_HIDDEN);
+        return;
+    }
+
+    const char* password = lv_textarea_get_text(view->password_textarea);
+    size_t password_len = strlen(password);
+    if (password_len > TT_WIFI_CREDENTIALS_PASSWORD_LIMIT) {
+        TT_LOG_E(TAG, "Password too long");
+        lv_label_set_text(view->password_error, "Password too long");
+        lv_obj_remove_flag(view->password_error, LV_OBJ_FLAG_HIDDEN);
+        return;
+    }
+
+    bool store = lv_obj_get_state(view->remember_switch) & LV_STATE_CHECKED;
+
+    view_set_loading(view, true);
+
+    service::wifi::settings::WifiApSettings settings;
+    strcpy((char*)settings.password, password);
+    strcpy((char*)settings.ssid, ssid);
+    settings.auto_connect = TT_WIFI_AUTO_CONNECT; // No UI yet, so use global setting:w
+
+    WifiConnectBindings* bindings = &wifi->bindings;
+    bindings->on_connect_ssid(
+        &settings,
+        store,
+        bindings->on_connect_ssid_context
+    );
+}
+
+static void view_set_loading(WifiConnectView* view, bool loading) {
+    if (loading) {
+        lv_obj_add_flag(view->connect_button, LV_OBJ_FLAG_HIDDEN);
+        lv_obj_remove_flag(view->connecting_spinner, LV_OBJ_FLAG_HIDDEN);
+        lv_obj_add_state(view->password_textarea, LV_STATE_DISABLED);
+        lv_obj_add_state(view->ssid_textarea, LV_STATE_DISABLED);
+        lv_obj_add_state(view->remember_switch, LV_STATE_DISABLED);
+    } else {
+        lv_obj_remove_flag(view->connect_button, LV_OBJ_FLAG_HIDDEN);
+        lv_obj_add_flag(view->connecting_spinner, LV_OBJ_FLAG_HIDDEN);
+        lv_obj_remove_state(view->password_textarea, LV_STATE_DISABLED);
+        lv_obj_remove_state(view->ssid_textarea, LV_STATE_DISABLED);
+        lv_obj_remove_state(view->remember_switch, LV_STATE_DISABLED);
+    }
+
+}
+
+void view_create_bottom_buttons(WifiConnect* wifi, lv_obj_t* parent) {
+    WifiConnectView* view = &wifi->view;
+
+    lv_obj_t* button_container = lv_obj_create(parent);
+    lv_obj_set_width(button_container, LV_PCT(100));
+    lv_obj_set_height(button_container, LV_SIZE_CONTENT);
+    lvgl::obj_set_style_no_padding(button_container);
+    lv_obj_set_style_border_width(button_container, 0, 0);
+
+    view->remember_switch = lv_switch_create(button_container);
+    lv_obj_add_state(view->remember_switch, LV_STATE_CHECKED);
+    lv_obj_align(view->remember_switch, LV_ALIGN_LEFT_MID, 0, 0);
+
+    lv_obj_t* remember_label = lv_label_create(button_container);
+    lv_label_set_text(remember_label, "Remember");
+    lv_obj_align(remember_label, LV_ALIGN_CENTER, 0, 0);
+    lv_obj_align_to(remember_label, view->remember_switch, LV_ALIGN_OUT_RIGHT_MID, 4, 0);
+
+    view->connecting_spinner = lv_spinner_create(button_container);
+    lv_obj_set_size(view->connecting_spinner, 32, 32);
+    lv_obj_align(view->connecting_spinner, LV_ALIGN_RIGHT_MID, 0, 0);
+    lv_obj_add_flag(view->connecting_spinner, LV_OBJ_FLAG_HIDDEN);
+
+    view->connect_button = lv_btn_create(button_container);
+    lv_obj_t* connect_label = lv_label_create(view->connect_button);
+    lv_label_set_text(connect_label, "Connect");
+    lv_obj_align(view->connect_button, LV_ALIGN_RIGHT_MID, 0, 0);
+    lv_obj_add_event_cb(view->connect_button, &on_connect, LV_EVENT_CLICKED, wifi);
+}
+
+// TODO: Standardize dialogs
+void view_create(App app, void* wifi, lv_obj_t* parent) {
+    WifiConnect* wifi_connect = (WifiConnect*)wifi;
+    WifiConnectView* view = &wifi_connect->view;
+
+    lv_obj_set_flex_flow(parent, LV_FLEX_FLOW_COLUMN);
+    lvgl::toolbar_create(parent, app);
+
+    lv_obj_t* wrapper = lv_obj_create(parent);
+    lv_obj_set_width(wrapper, LV_PCT(100));
+    lv_obj_set_flex_grow(wrapper, 1);
+    lv_obj_set_flex_flow(wrapper, LV_FLEX_FLOW_COLUMN);
+
+    // SSID
+
+    lv_obj_t* ssid_wrapper = lv_obj_create(wrapper);
+    lv_obj_set_width(ssid_wrapper, LV_PCT(100));
+    lv_obj_set_height(ssid_wrapper, LV_SIZE_CONTENT);
+    lvgl::obj_set_style_no_padding(ssid_wrapper);
+    lv_obj_set_style_border_width(ssid_wrapper, 0, 0);
+
+    lv_obj_t* ssid_label_wrapper = lv_obj_create(ssid_wrapper);
+    lv_obj_set_width(ssid_label_wrapper, LV_PCT(50));
+    lv_obj_set_height(ssid_label_wrapper, LV_SIZE_CONTENT);
+    lv_obj_align(ssid_label_wrapper, LV_ALIGN_LEFT_MID, 0, 0);
+    lv_obj_set_style_border_width(ssid_label_wrapper, 0, 0);
+    lv_obj_set_style_pad_left(ssid_label_wrapper, 0, 0);
+    lv_obj_set_style_pad_right(ssid_label_wrapper, 0, 0);
+
+    lv_obj_t* ssid_label = lv_label_create(ssid_label_wrapper);
+    lv_label_set_text(ssid_label, "Network:");
+
+    view->ssid_textarea = lv_textarea_create(ssid_wrapper);
+    lv_textarea_set_one_line(view->ssid_textarea, true);
+    lv_obj_align(view->ssid_textarea, LV_ALIGN_RIGHT_MID, 0, 0);
+    lv_obj_set_width(view->ssid_textarea, LV_PCT(50));
+
+    view->ssid_error = lv_label_create(wrapper);
+    lv_obj_set_style_text_color(view->ssid_error, lv_color_make(255, 50, 50), 0);
+    lv_obj_add_flag(view->ssid_error, LV_OBJ_FLAG_HIDDEN);
+
+    // Password
+
+    lv_obj_t* password_wrapper = lv_obj_create(wrapper);
+    lv_obj_set_width(password_wrapper, LV_PCT(100));
+    lv_obj_set_height(password_wrapper, LV_SIZE_CONTENT);
+    lvgl::obj_set_style_no_padding(password_wrapper);
+    lv_obj_set_style_border_width(password_wrapper, 0, 0);
+
+    lv_obj_t* password_label_wrapper = lv_obj_create(password_wrapper);
+    lv_obj_set_width(password_label_wrapper, LV_PCT(50));
+    lv_obj_set_height(password_label_wrapper, LV_SIZE_CONTENT);
+    lv_obj_align_to(password_label_wrapper, password_wrapper, LV_ALIGN_LEFT_MID, 0, 0);
+    lv_obj_set_style_border_width(password_label_wrapper, 0, 0);
+    lv_obj_set_style_pad_left(password_label_wrapper, 0, 0);
+    lv_obj_set_style_pad_right(password_label_wrapper, 0, 0);
+
+    lv_obj_t* password_label = lv_label_create(password_label_wrapper);
+    lv_label_set_text(password_label, "Password:");
+
+    view->password_textarea = lv_textarea_create(password_wrapper);
+    lv_textarea_set_one_line(view->password_textarea, true);
+    lv_textarea_set_password_mode(view->password_textarea, true);
+    lv_obj_align(view->password_textarea, LV_ALIGN_RIGHT_MID, 0, 0);
+    lv_obj_set_width(view->password_textarea, LV_PCT(50));
+
+    view->password_error = lv_label_create(wrapper);
+    lv_obj_set_style_text_color(view->password_error, lv_color_make(255, 50, 50), 0);
+    lv_obj_add_flag(view->password_error, LV_OBJ_FLAG_HIDDEN);
+
+    // Connection error
+    view->connection_error = lv_label_create(wrapper);
+    lv_obj_set_style_text_color(view->connection_error, lv_color_make(255, 50, 50), 0);
+    lv_obj_add_flag(view->connection_error, LV_OBJ_FLAG_HIDDEN);
+
+    // Bottom buttons
+    view_create_bottom_buttons(wifi_connect, wrapper);
+
+    // Keyboard bindings
+    service::gui::keyboard_add_textarea(view->ssid_textarea);
+    service::gui::keyboard_add_textarea(view->password_textarea);
+
+    // Init from app parameters
+    const Bundle& bundle = tt_app_get_parameters(app);
+    std::string ssid;
+    if (bundle.optString(WIFI_CONNECT_PARAM_SSID, ssid)) {
+        lv_textarea_set_text(view->ssid_textarea, ssid.c_str());
+    }
+
+    std::string password;
+    if (bundle.optString(WIFI_CONNECT_PARAM_PASSWORD, password)) {
+        lv_textarea_set_text(view->password_textarea, password.c_str());
+    }
+}
+
+void view_destroy(TT_UNUSED WifiConnectView* view) {
+    // NO-OP
+}
+
+void view_update(
+    WifiConnectView* view,
+    TT_UNUSED WifiConnectBindings* bindings,
+    WifiConnectState* state
+) {
+    if (state->connection_error) {
+        view_set_loading(view, false);
+        reset_errors(view);
+        lv_label_set_text(view->connection_error, "Connection failed");
+        lv_obj_remove_flag(view->connection_error, LV_OBJ_FLAG_HIDDEN);
+    }
+}
+
+} // namespace

Tactility/Source/app/wificonnect/WifiConnectView.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "app/App.h"
+#include "WifiConnectBindings.h"
+#include "WifiConnectState.h"
+#include "lvgl.h"
+
+namespace tt::app::wificonnect {
+
+typedef struct {
+    lv_obj_t* ssid_textarea;
+    lv_obj_t* ssid_error;
+    lv_obj_t* password_textarea;
+    lv_obj_t* password_error;
+    lv_obj_t* connect_button;
+    lv_obj_t* cancel_button;
+    lv_obj_t* remember_switch;
+    lv_obj_t* connecting_spinner;
+    lv_obj_t* connection_error;
+    lv_group_t* group;
+} WifiConnectView;
+
+void view_create(App app, void* wifi, lv_obj_t* parent);
+void view_update(WifiConnectView* view, WifiConnectBindings* bindings, WifiConnectState* state);
+void view_destroy(WifiConnectView* view);
+
+} // namespace