summaryrefslogtreecommitdiff
path: root/src/ui
diff options
context:
space:
mode:
Diffstat (limited to 'src/ui')
-rw-r--r--src/ui/CMakeLists.txt8
-rw-r--r--src/ui/encoder_input.cpp358
-rw-r--r--src/ui/include/encoder_input.hpp107
-rw-r--r--src/ui/include/lvgl_task.hpp7
-rw-r--r--src/ui/include/ui_fsm.hpp5
-rw-r--r--src/ui/lvgl_task.cpp15
-rw-r--r--src/ui/ui_fsm.cpp122
7 files changed, 68 insertions, 554 deletions
diff --git a/src/ui/CMakeLists.txt b/src/ui/CMakeLists.txt
index 6d45fc9f..3814e9d5 100644
--- a/src/ui/CMakeLists.txt
+++ b/src/ui/CMakeLists.txt
@@ -3,9 +3,9 @@
# SPDX-License-Identifier: GPL-3.0-only
idf_component_register(
- SRCS "lvgl_task.cpp" "ui_fsm.cpp" "screen_splash.cpp" "encoder_input.cpp"
- "themes.cpp" "screen.cpp" "modal.cpp" "screen_lua.cpp"
- "splash.c" "font_fusion_12.c" "font_fusion_10.c"
+ SRCS "lvgl_task.cpp" "ui_fsm.cpp" "screen_splash.cpp" "themes.cpp"
+ "screen.cpp" "modal.cpp" "screen_lua.cpp" "splash.c" "font_fusion_12.c"
+ "font_fusion_10.c"
INCLUDE_DIRS "include"
- REQUIRES "drivers" "lvgl" "tinyfsm" "events" "system_fsm" "database" "esp_timer" "battery" "lua" "luavgl" "esp_app_format")
+ REQUIRES "drivers" "lvgl" "tinyfsm" "events" "system_fsm" "database" "esp_timer" "battery" "lua" "luavgl" "esp_app_format" "input")
target_compile_options(${COMPONENT_LIB} PRIVATE ${EXTRA_WARNINGS})
diff --git a/src/ui/encoder_input.cpp b/src/ui/encoder_input.cpp
deleted file mode 100644
index 3b5af2c1..00000000
--- a/src/ui/encoder_input.cpp
+++ /dev/null
@@ -1,358 +0,0 @@
-/*
- * Copyright 2023 jacqueline <me@jacqueline.id.au>
- *
- * SPDX-License-Identifier: GPL-3.0-only
- */
-
-#include "encoder_input.hpp"
-
-#include <sys/_stdint.h>
-#include <memory>
-
-#include "lvgl.h"
-
-#include "audio_events.hpp"
-#include "core/lv_event.h"
-#include "core/lv_group.h"
-#include "esp_timer.h"
-#include "event_queue.hpp"
-#include "gpios.hpp"
-#include "hal/lv_hal_indev.h"
-#include "nvs.hpp"
-#include "relative_wheel.hpp"
-#include "touchwheel.hpp"
-#include "ui_events.hpp"
-
-[[maybe_unused]] static constexpr char kTag[] = "input";
-
-constexpr int kDPadAngleThreshold = 10;
-constexpr int kLongPressDelayMs = 500;
-constexpr int kRepeatDelayMs = 250;
-
-static inline auto IsAngleWithin(int16_t wheel_angle,
- int16_t target_angle,
- int threshold) -> bool {
- int16_t difference = (wheel_angle - target_angle + 127 + 255) % 255 - 127;
- return difference <= threshold && difference >= -threshold;
-}
-
-namespace ui {
-
-static void encoder_read(lv_indev_drv_t* drv, lv_indev_data_t* data) {
- EncoderInput* instance = reinterpret_cast<EncoderInput*>(drv->user_data);
- instance->Read(data);
-}
-
-EncoderInput::EncoderInput(drivers::IGpios& gpios, drivers::TouchWheel& wheel)
- : gpios_(gpios),
- raw_wheel_(wheel),
- relative_wheel_(std::make_unique<drivers::RelativeWheel>(wheel)),
- scroller_(std::make_unique<Scroller>()),
- mode_(drivers::NvsStorage::InputModes::kRotatingWheel),
- is_locked_(false),
- scroll_sensitivity_(10),
- is_scrolling_wheel_(false) {
- lv_indev_drv_init(&driver_);
- driver_.type = LV_INDEV_TYPE_ENCODER;
- driver_.read_cb = encoder_read;
- driver_.user_data = this;
-
- registration_ = lv_indev_drv_register(&driver_);
-}
-
-auto EncoderInput::Read(lv_indev_data_t* data) -> void {
- if (is_locked_) {
- return;
- }
-
- lv_obj_t* active_object = nullptr;
- if (registration_ && registration_->group) {
- active_object = lv_group_get_focused(registration_->group);
- }
-
- raw_wheel_.Update();
- relative_wheel_->Update();
- // GPIO (for volume buttons) updating is handled by system_fsm.
-
- uint64_t now_ms = esp_timer_get_time() / 1000;
-
- // Deal with the potential overflow of our timer.
- for (auto& it : touch_time_ms_) {
- if (it.second > now_ms) {
- // esp_timer overflowed.
- it.second = 0;
- }
- }
-
- // Check each button.
- UpdateKeyState(Keys::kVolumeUp, now_ms,
- !gpios_.Get(drivers::IGpios::Pin::kKeyUp));
- UpdateKeyState(Keys::kVolumeDown, now_ms,
- !gpios_.Get(drivers::IGpios::Pin::kKeyDown));
-
- drivers::TouchWheelData wheel_data = raw_wheel_.GetTouchWheelData();
- UpdateKeyState(Keys::kTouchWheel, now_ms, wheel_data.is_wheel_touched);
- UpdateKeyState(Keys::kTouchWheelCenter, now_ms, wheel_data.is_button_touched);
-
- UpdateKeyState(
- Keys::kDirectionalUp, now_ms,
- wheel_data.is_wheel_touched &&
- IsAngleWithin(wheel_data.wheel_position, 0, kDPadAngleThreshold));
- UpdateKeyState(
- Keys::kDirectionalLeft, now_ms,
- wheel_data.is_wheel_touched &&
- IsAngleWithin(wheel_data.wheel_position, 63, kDPadAngleThreshold));
- UpdateKeyState(
- Keys::kDirectionalDown, now_ms,
- wheel_data.is_wheel_touched &&
- IsAngleWithin(wheel_data.wheel_position, 127, kDPadAngleThreshold));
- UpdateKeyState(
- Keys::kDirectionalRight, now_ms,
- wheel_data.is_wheel_touched &&
- IsAngleWithin(wheel_data.wheel_position, 189, kDPadAngleThreshold));
-
- // When the wheel is being scrolled, we want to ensure that other inputs
- // involving the touchwheel don't trigger. This guards again two main issues:
- // - hesitating when your thumb is on a cardinal direction, causing an
- // unintentional long-press,
- // - drifting from the outside of the wheel in a way that causes the centre
- // key to be triggered.
- if (is_scrolling_wheel_) {
- UpdateKeyState(Keys::kTouchWheelCenter, now_ms, false);
- UpdateKeyState(Keys::kDirectionalUp, now_ms, false);
- UpdateKeyState(Keys::kDirectionalLeft, now_ms, false);
- UpdateKeyState(Keys::kDirectionalDown, now_ms, false);
- UpdateKeyState(Keys::kDirectionalRight, now_ms, false);
- }
-
- // Now that we've determined the correct state for all keys, we can start
- // mapping key states into actions, depending on the current control scheme.
- if (mode_ == drivers::NvsStorage::InputModes::kButtonsOnly) {
- Trigger trigger;
- data->state = LV_INDEV_STATE_RELEASED;
-
- trigger = TriggerKey(Keys::kVolumeUp, KeyStyle::kLongPress, now_ms);
- switch (trigger) {
- case Trigger::kNone:
- break;
- case Trigger::kClick:
- data->enc_diff = -1;
- break;
- case Trigger::kLongPress:
- events::Ui().Dispatch(internal::BackPressed{});
- break;
- }
-
- trigger = TriggerKey(Keys::kVolumeDown, KeyStyle::kLongPress, now_ms);
- switch (trigger) {
- case Trigger::kNone:
- break;
- case Trigger::kClick:
- data->enc_diff = 1;
- break;
- case Trigger::kLongPress:
- data->state = LV_INDEV_STATE_PRESSED;
- break;
- }
- } else if (mode_ == drivers::NvsStorage::InputModes::kDirectionalWheel) {
- Trigger trigger;
- trigger = TriggerKey(Keys::kTouchWheelCenter, KeyStyle::kLongPress, now_ms);
- data->state = trigger == Trigger::kClick ? LV_INDEV_STATE_PRESSED
- : LV_INDEV_STATE_RELEASED;
-
- trigger = TriggerKey(Keys::kDirectionalUp, KeyStyle::kRepeat, now_ms);
- if (trigger == Trigger::kClick) {
- data->enc_diff = scroller_->AddInput(now_ms, -1);
- }
-
- trigger = TriggerKey(Keys::kDirectionalDown, KeyStyle::kRepeat, now_ms);
- if (trigger == Trigger::kClick) {
- data->enc_diff = scroller_->AddInput(now_ms, 1);
- }
-
- trigger = TriggerKey(Keys::kDirectionalLeft, KeyStyle::kRepeat, now_ms);
- if (trigger == Trigger::kClick) {
- events::Ui().Dispatch(internal::BackPressed{});
- }
-
- trigger = TriggerKey(Keys::kDirectionalRight, KeyStyle::kRepeat, now_ms);
- if (trigger == Trigger::kClick) {
- // TODO: ???
- }
-
- // Cancel scrolling if the touchpad is released.
- if (!touch_time_ms_.contains(Keys::kDirectionalUp) &&
- !touch_time_ms_.contains(Keys::kDirectionalDown)) {
- data->enc_diff = scroller_->AddInput(now_ms, 0);
- }
-
- trigger = TriggerKey(Keys::kVolumeUp, KeyStyle::kRepeat, now_ms);
- switch (trigger) {
- case Trigger::kNone:
- break;
- case Trigger::kClick:
- events::Audio().Dispatch(audio::StepUpVolume{});
- break;
- case Trigger::kLongPress:
- break;
- }
-
- trigger = TriggerKey(Keys::kVolumeDown, KeyStyle::kRepeat, now_ms);
- switch (trigger) {
- case Trigger::kNone:
- break;
- case Trigger::kClick:
- events::Audio().Dispatch(audio::StepDownVolume{});
- break;
- case Trigger::kLongPress:
- break;
- }
- } else if (mode_ == drivers::NvsStorage::InputModes::kRotatingWheel) {
- if (!raw_wheel_.GetTouchWheelData().is_wheel_touched) {
- // User has released the wheel.
- is_scrolling_wheel_ = false;
- data->enc_diff = scroller_->AddInput(now_ms, 0);
- } else if (relative_wheel_->ticks() != 0) {
- // User is touching the wheel, and has just passed the sensitivity
- // threshold for a scroll tick.
- is_scrolling_wheel_ = true;
- data->enc_diff = scroller_->AddInput(now_ms, relative_wheel_->ticks());
- } else {
- // User is touching the wheel, but hasn't moved.
- data->enc_diff = 0;
- }
-
- Trigger trigger =
- TriggerKey(Keys::kTouchWheelCenter, KeyStyle::kLongPress, now_ms);
- switch (trigger) {
- case Trigger::kNone:
- data->state = LV_INDEV_STATE_RELEASED;
- break;
- case Trigger::kClick:
- data->state = LV_INDEV_STATE_PRESSED;
- break;
- case Trigger::kLongPress:
- if (active_object) {
- lv_event_send(active_object, LV_EVENT_LONG_PRESSED, NULL);
- }
- break;
- }
-
- trigger = TriggerKey(Keys::kVolumeUp, KeyStyle::kRepeat, now_ms);
- switch (trigger) {
- case Trigger::kNone:
- break;
- case Trigger::kClick:
- events::Audio().Dispatch(audio::StepUpVolume{});
- break;
- case Trigger::kLongPress:
- break;
- }
-
- trigger = TriggerKey(Keys::kVolumeDown, KeyStyle::kRepeat, now_ms);
- switch (trigger) {
- case Trigger::kNone:
- break;
- case Trigger::kClick:
- events::Audio().Dispatch(audio::StepDownVolume{});
- break;
- case Trigger::kLongPress:
- break;
- }
-
- trigger = TriggerKey(Keys::kDirectionalLeft, KeyStyle::kLongPress, now_ms);
- switch (trigger) {
- case Trigger::kNone:
- break;
- case Trigger::kClick:
- break;
- case Trigger::kLongPress:
- events::Ui().Dispatch(internal::BackPressed{});
- break;
- }
- }
-}
-
-auto EncoderInput::scroll_sensitivity(uint8_t val) -> void {
- scroll_sensitivity_ = val;
- relative_wheel_->SetSensitivity(scroll_sensitivity_);
-}
-
-auto EncoderInput::UpdateKeyState(Keys key, uint64_t ms, bool clicked) -> void {
- if (clicked) {
- if (!touch_time_ms_.contains(key)) {
- // Key was just clicked.
- touch_time_ms_[key] = ms;
- just_released_.erase(key);
- fired_.erase(key);
- }
- return;
- }
-
- // Key is not clicked.
- if (touch_time_ms_.contains(key)) {
- // Key was just released.
- just_released_.insert(key);
- touch_time_ms_.erase(key);
- }
-}
-
-auto EncoderInput::TriggerKey(Keys key, KeyStyle s, uint64_t ms) -> Trigger {
- if (s == KeyStyle::kRepeat) {
- bool may_repeat = fired_.contains(key) && touch_time_ms_.contains(key) &&
- ms - touch_time_ms_[key] >= kRepeatDelayMs;
-
- // Repeatable keys trigger on press.
- if (touch_time_ms_.contains(key) && (!fired_.contains(key) || may_repeat)) {
- fired_.insert(key);
- return Trigger::kClick;
- } else {
- return Trigger::kNone;
- }
- } else if (s == KeyStyle::kLongPress) {
- // Long press keys trigger on release, or after holding for a delay.
- if (just_released_.contains(key)) {
- just_released_.erase(key);
- if (!fired_.contains(key)) {
- fired_.insert(key);
- return Trigger::kClick;
- }
- }
- if (touch_time_ms_.contains(key) &&
- ms - touch_time_ms_[key] >= kLongPressDelayMs &&
- !fired_.contains(key)) {
- fired_.insert(key);
- return Trigger::kLongPress;
- }
- }
-
- return Trigger::kNone;
-}
-
-auto Scroller::AddInput(uint64_t ms, int direction) -> int {
- bool dir_changed =
- ((velocity_ < 0 && direction > 0) || (velocity_ > 0 && direction < 0));
- if (direction == 0 || dir_changed) {
- last_input_ms_ = ms;
- velocity_ = 0;
- return 0;
- }
- // Decay with time
- if (last_input_ms_ > ms) {
- last_input_ms_ = 0;
- }
- uint diff = ms - last_input_ms_;
- uint diff_steps = diff / 25;
- last_input_ms_ = ms + (last_input_ms_ % 50);
- // Use powers of two for our exponential decay so we can implement decay
- // trivially via bit shifting.
- velocity_ >>= diff_steps;
-
- velocity_ += direction * 1000;
- if (velocity_ > 0) {
- return (velocity_ + 500) / 1000;
- } else {
- return (velocity_ - 500) / 1000;
- }
-}
-} // namespace ui
diff --git a/src/ui/include/encoder_input.hpp b/src/ui/include/encoder_input.hpp
deleted file mode 100644
index 7dfac071..00000000
--- a/src/ui/include/encoder_input.hpp
+++ /dev/null
@@ -1,107 +0,0 @@
-/*
- * Copyright 2023 jacqueline <me@jacqueline.id.au>
- *
- * SPDX-License-Identifier: GPL-3.0-only
- */
-
-#pragma once
-
-#include <stdint.h>
-#include <deque>
-#include <memory>
-#include <set>
-
-#include "core/lv_group.h"
-#include "gpios.hpp"
-#include "hal/lv_hal_indev.h"
-
-#include "nvs.hpp"
-#include "relative_wheel.hpp"
-#include "touchwheel.hpp"
-
-namespace ui {
-
-class Scroller;
-
-/*
- * Main input device abstracting that handles turning lower-level input device
- * drivers into events and LVGL inputs.
- *
- * As far as LVGL is concerned, this class represents an ordinary rotary
- * encoder, supporting only left and right ticks, and clicking.
- */
-class EncoderInput {
- public:
- EncoderInput(drivers::IGpios& gpios, drivers::TouchWheel& wheel);
-
- auto Read(lv_indev_data_t* data) -> void;
- auto registration() -> lv_indev_t* { return registration_; }
-
- auto mode(drivers::NvsStorage::InputModes mode) { mode_ = mode; }
- auto scroll_sensitivity(uint8_t val) -> void; // Value between 0-255, used to scale the threshold
- auto lock(bool l) -> void { is_locked_ = l; }
-
- private:
- lv_indev_drv_t driver_;
- lv_indev_t* registration_;
-
- drivers::IGpios& gpios_;
- drivers::TouchWheel& raw_wheel_;
- std::unique_ptr<drivers::RelativeWheel> relative_wheel_;
- std::unique_ptr<Scroller> scroller_;
-
- drivers::NvsStorage::InputModes mode_;
- bool is_locked_;
- uint8_t scroll_sensitivity_;
-
- // Every kind of distinct input that we could map to an action.
- enum class Keys {
- kVolumeUp,
- kVolumeDown,
- kTouchWheel,
- kTouchWheelCenter,
- kDirectionalUp,
- kDirectionalRight,
- kDirectionalDown,
- kDirectionalLeft,
- };
-
- // Map from a Key, to the time that it was first touched in ms. If the key is
- // currently released, where will be no entry.
- std::unordered_map<Keys, uint64_t> touch_time_ms_;
- // Set of keys that were released during the current update.
- std::set<Keys> just_released_;
- // Set of keys that have had an event fired for them since being pressed.
- std::set<Keys> fired_;
-
- bool is_scrolling_wheel_;
-
- enum class Trigger {
- kNone,
- // Regular short-click. Triggered on release for long-pressable keys,
- // triggered on the initial press for repeatable keys.
- kClick,
- kLongPress,
- };
-
- enum class KeyStyle {
- kRepeat,
- kLongPress,
- };
-
- auto UpdateKeyState(Keys key, uint64_t ms, bool clicked) -> void;
- auto TriggerKey(Keys key, KeyStyle t, uint64_t ms) -> Trigger;
-};
-
-class Scroller {
- public:
- Scroller() : last_input_ms_(0), velocity_(0) {}
-
- auto AddInput(uint64_t, int) -> int;
-
- private:
- uint64_t last_input_ms_;
- int velocity_;
-};
-
-} // namespace ui
diff --git a/src/ui/include/lvgl_task.hpp b/src/ui/include/lvgl_task.hpp
index f212ab9d..8efcbf35 100644
--- a/src/ui/include/lvgl_task.hpp
+++ b/src/ui/include/lvgl_task.hpp
@@ -15,8 +15,7 @@
#include "freertos/timers.h"
#include "display.hpp"
-#include "encoder_input.hpp"
-#include "relative_wheel.hpp"
+#include "lvgl_input_driver.hpp"
#include "screen.hpp"
#include "themes.hpp"
#include "touchwheel.hpp"
@@ -28,14 +27,14 @@ class UiTask {
static auto Start() -> UiTask*;
~UiTask();
- auto input(std::shared_ptr<EncoderInput> input) -> void;
+ auto input(std::shared_ptr<input::LvglInputDriver> input) -> void;
private:
UiTask();
auto Main() -> void;
- std::shared_ptr<EncoderInput> input_;
+ std::shared_ptr<input::LvglInputDriver> input_;
std::shared_ptr<Screen> current_screen_;
};
diff --git a/src/ui/include/ui_fsm.hpp b/src/ui/include/ui_fsm.hpp
index 2bab487d..c238a447 100644
--- a/src/ui/include/ui_fsm.hpp
+++ b/src/ui/include/ui_fsm.hpp
@@ -14,14 +14,13 @@
#include "battery.hpp"
#include "db_events.hpp"
#include "display.hpp"
-#include "encoder_input.hpp"
#include "gpios.hpp"
#include "lua_thread.hpp"
+#include "lvgl_input_driver.hpp"
#include "lvgl_task.hpp"
#include "modal.hpp"
#include "nvs.hpp"
#include "property.hpp"
-#include "relative_wheel.hpp"
#include "screen.hpp"
#include "service_locator.hpp"
#include "storage.hpp"
@@ -92,7 +91,7 @@ class UiState : public tinyfsm::Fsm<UiState> {
static std::unique_ptr<UiTask> sTask;
static std::shared_ptr<system_fsm::ServiceLocator> sServices;
static std::unique_ptr<drivers::Display> sDisplay;
- static std::shared_ptr<EncoderInput> sInput;
+ static std::shared_ptr<input::LvglInputDriver> sInput;
static std::stack<std::shared_ptr<Screen>> sScreens;
static std::shared_ptr<Screen> sCurrentScreen;
diff --git a/src/ui/lvgl_task.cpp b/src/ui/lvgl_task.cpp
index f0184766..4cf25c15 100644
--- a/src/ui/lvgl_task.cpp
+++ b/src/ui/lvgl_task.cpp
@@ -33,11 +33,11 @@
#include "lua.h"
#include "lv_api_map.h"
#include "lvgl/lvgl.h"
+#include "lvgl_input_driver.hpp"
#include "misc/lv_color.h"
#include "misc/lv_style.h"
#include "misc/lv_timer.h"
#include "modal.hpp"
-#include "relative_wheel.hpp"
#include "tasks.hpp"
#include "touchwheel.hpp"
#include "ui_fsm.hpp"
@@ -50,8 +50,6 @@ namespace ui {
[[maybe_unused]] static const char* kTag = "ui_task";
-static auto group_focus_cb(lv_group_t *group) -> void;
-
UiTask::UiTask() {}
UiTask::~UiTask() {
@@ -78,7 +76,6 @@ auto UiTask::Main() -> void {
if (input_ && current_screen_->group() != current_group) {
current_group = current_screen_->group();
lv_indev_set_group(input_->registration(), current_group);
- lv_group_set_focus_cb(current_group, &group_focus_cb);
}
TickType_t delay = lv_timer_handler();
@@ -86,10 +83,9 @@ auto UiTask::Main() -> void {
}
}
-auto UiTask::input(std::shared_ptr<EncoderInput> input) -> void {
+auto UiTask::input(std::shared_ptr<input::LvglInputDriver> input) -> void {
assert(current_screen_);
input_ = input;
- lv_indev_set_group(input_->registration(), current_screen_->group());
}
auto UiTask::Start() -> UiTask* {
@@ -98,11 +94,4 @@ auto UiTask::Start() -> UiTask* {
return ret;
}
-static auto group_focus_cb(lv_group_t *group) -> void {
- // TODO(robin): we probably want to vary this, configure this, etc
- events::System().Dispatch(system_fsm::HapticTrigger{
- .effect = drivers::Haptics::Effect::kMediumClick1_100Pct,
- });
-}
-
} // namespace ui
diff --git a/src/ui/ui_fsm.cpp b/src/ui/ui_fsm.cpp
index 28733123..a9c1d3a3 100644
--- a/src/ui/ui_fsm.cpp
+++ b/src/ui/ui_fsm.cpp
@@ -30,19 +30,18 @@
#include "lauxlib.h"
#include "lua_thread.hpp"
#include "luavgl.h"
+#include "lvgl_input_driver.hpp"
#include "memory_resource.hpp"
#include "misc/lv_gc.h"
#include "audio_events.hpp"
#include "display.hpp"
-#include "encoder_input.hpp"
#include "event_queue.hpp"
#include "gpios.hpp"
#include "lua_registry.hpp"
#include "lvgl_task.hpp"
#include "nvs.hpp"
#include "property.hpp"
-#include "relative_wheel.hpp"
#include "samd.hpp"
#include "screen.hpp"
#include "screen_lua.hpp"
@@ -63,7 +62,7 @@ namespace ui {
std::unique_ptr<UiTask> UiState::sTask;
std::shared_ptr<system_fsm::ServiceLocator> UiState::sServices;
std::unique_ptr<drivers::Display> UiState::sDisplay;
-std::shared_ptr<EncoderInput> UiState::sInput;
+std::shared_ptr<input::LvglInputDriver> UiState::sInput;
std::stack<std::shared_ptr<Screen>> UiState::sScreens;
std::shared_ptr<Screen> UiState::sCurrentScreen;
@@ -234,51 +233,58 @@ lua::Property UiState::sDisplayBrightness{
return true;
}};
-lua::Property UiState::sControlsScheme{
- 0, [](const lua::LuaValue& val) {
- if (!std::holds_alternative<int>(val)) {
- return false;
- }
- drivers::NvsStorage::InputModes mode;
- switch (std::get<int>(val)) {
- case 0:
- mode = drivers::NvsStorage::InputModes::kButtonsOnly;
- break;
- case 1:
- mode = drivers::NvsStorage::InputModes::kButtonsWithWheel;
- break;
- case 2:
- mode = drivers::NvsStorage::InputModes::kDirectionalWheel;
- break;
- case 3:
- mode = drivers::NvsStorage::InputModes::kRotatingWheel;
- break;
- default:
- return false;
- }
- sServices->nvs().PrimaryInput(mode);
- sInput->mode(mode);
- return true;
- }};
-
-lua::Property UiState::sScrollSensitivity{
- 0, [](const lua::LuaValue& val) {
- std::optional<int> sensitivity = 0;
- std::visit(
- [&](auto&& v) {
- using T = std::decay_t<decltype(v)>;
- if constexpr (std::is_same_v<T, int>) {
- sensitivity = v;
- }
- },
- val);
- if (!sensitivity) {
- return false;
- }
- sInput->scroll_sensitivity(*sensitivity);
- sServices->nvs().ScrollSensitivity(*sensitivity);
- return true;
- }};
+lua::Property UiState::sControlsScheme{0, [](const lua::LuaValue& val) {
+ /*
+ if (!std::holds_alternative<int>(val))
+ { return false;
+ }
+ drivers::NvsStorage::InputModes mode;
+ switch (std::get<int>(val)) {
+ case 0:
+ mode =
+ drivers::NvsStorage::InputModes::kButtonsOnly;
+ break;
+ case 1:
+ mode =
+ drivers::NvsStorage::InputModes::kButtonsWithWheel;
+ break;
+ case 2:
+ mode =
+ drivers::NvsStorage::InputModes::kDirectionalWheel;
+ break;
+ case 3:
+ mode =
+ drivers::NvsStorage::InputModes::kRotatingWheel;
+ break;
+ default:
+ return false;
+ }
+ sServices->nvs().PrimaryInput(mode);
+ sInput->mode(mode);
+ */
+ return true;
+ }};
+
+lua::Property UiState::sScrollSensitivity{0, [](const lua::LuaValue& val) {
+ /*
+ std::optional<int> sensitivity = 0;
+ std::visit(
+ [&](auto&& v) {
+ using T =
+ std::decay_t<decltype(v)>; if
+ constexpr (std::is_same_v<T, int>) {
+ sensitivity = v;
+ }
+ },
+ val);
+ if (!sensitivity) {
+ return false;
+ }
+ sInput->scroll_sensitivity(*sensitivity);
+ sServices->nvs().ScrollSensitivity(*sensitivity);
+ */
+ return true;
+ }};
lua::Property UiState::sLockSwitch{false};
@@ -372,7 +378,7 @@ void UiState::react(const internal::ControlSchemeChanged&) {
if (!sInput) {
return;
}
- sInput->mode(sServices->nvs().PrimaryInput());
+ // sInput->mode(sServices->nvs().PrimaryInput());
}
void UiState::react(const database::event::UpdateStarted&) {
@@ -478,22 +484,8 @@ void Splash::react(const system_fsm::BootComplete& ev) {
sDisplayBrightness.Update(brightness);
sDisplay->SetBrightness(brightness);
- auto touchwheel = sServices->touchwheel();
- if (touchwheel) {
- sInput = std::make_shared<EncoderInput>(sServices->gpios(), **touchwheel);
-
- auto mode = sServices->nvs().PrimaryInput();
- sInput->mode(mode);
- sControlsScheme.Update(static_cast<int>(mode));
-
- auto sensitivity = sServices->nvs().ScrollSensitivity();
- sInput->scroll_sensitivity(sensitivity);
- sScrollSensitivity.Update(static_cast<int>(sensitivity));
-
- sTask->input(sInput);
- } else {
- ESP_LOGE(kTag, "no input devices initialised!");
- }
+ sInput = std::make_shared<input::LvglInputDriver>(sServices);
+ sTask->input(sInput);
}
void Splash::react(const system_fsm::StorageMounted&) {
generated by cgit v1.2.3 (git 2.25.1) at 2026-04-30 00:45:55 +0000