Merge pull request 'Add optional support for adjusting volume while locked' (#230) from teisenbe/tangara-fw:locked_input into main

Reviewed-on: https://codeberg.org/cool-tech-zone/tangara-fw/pulls/230

lua/settings.lua

@@ -385,44 +385,58 @@ settings.InputSettings = SettingsScreen:new {
   create_ui = function(self)
     SettingsScreen.create_ui(self)
 
-    theme.set_subject(self.content:Label {
-      text = "Control scheme",
-    }, "settings_title")
+    -- Use the control scheme enum lists to generate the relevant dropdowns
+    local make_scheme_control = function(self, scheme_list, control_scheme)
+        local option_to_scheme = {}
+        local scheme_to_option = {}
+        local option_idx = 0
+        local options = ""
+
+        -- Sort the keys to order the dropdowns the same as the enums
+        keys = {}
+        for i in pairs(scheme_list) do table.insert(keys, i) end
+        table.sort(keys)
+
+        for i, k in pairs(keys) do
+          v = scheme_list[k]
+
+          option_to_scheme[option_idx] = k
+          scheme_to_option[k] = option_idx
+          if option_idx > 0 then
+            options = options .. "\n"
+          end
+          options = options .. v
+          option_idx = option_idx + 1
+        end
 
-    local schemes = controls.schemes()
-    local option_to_scheme = {}
-    local scheme_to_option = {}
+        local controls_chooser = self.content:Dropdown {
+          options = options,
+          symbol = img.chevron,
+        }
 
-    local option_idx = 0
-    local options = ""
+        self.bindings = self.bindings + {
+          control_scheme:bind(function(s)
+            local option = scheme_to_option[s]
+            controls_chooser:set({ selected = option })
+          end)
+        }
 
-    for i, v in pairs(schemes) do
-      option_to_scheme[option_idx] = i
-      scheme_to_option[i] = option_idx
-      if option_idx > 0 then
-        options = options .. "\n"
-      end
-      options = options .. v
-      option_idx = option_idx + 1
+        controls_chooser:onevent(lvgl.EVENT.VALUE_CHANGED, function()
+          local option = controls_chooser:get('selected')
+          local scheme = option_to_scheme[option]
+          control_scheme:set(scheme)
+        end)
     end
 
-    local controls_chooser = self.content:Dropdown {
-      options = options,
-      symbol = img.chevron,
-    }
-
-    self.bindings = self.bindings + {
-      controls.scheme:bind(function(s)
-        local option = scheme_to_option[s]
-        controls_chooser:set({ selected = option })
-      end)
-    }
+    theme.set_subject(self.content:Label {
+      text = "Control scheme",
+    }, "settings_title")
+    make_scheme_control(self, controls.schemes(), controls.scheme)
 
-    controls_chooser:onevent(lvgl.EVENT.VALUE_CHANGED, function()
-      local option = controls_chooser:get('selected')
-      local scheme = option_to_scheme[option]
-      controls.scheme:set(scheme)
-    end)
+    theme.set_subject(self.content:Label {
+      text = "Control scheme when locked",
+    }, "settings_title")
+    make_scheme_control(self, controls.locked_schemes(), controls.locked_scheme)
 
     controls_chooser:focus()
 

src/drivers/include/drivers/nvs.hpp

@@ -138,6 +138,14 @@ class NvsStorage {
   auto PrimaryInput() -> InputModes;
   auto PrimaryInput(InputModes) -> void;
 
+  enum class LockedInputModes : uint8_t {
+    kDisabled = 0,
+    kVolumeOnly = 1,
+  };
+
+  auto LockedInput() -> LockedInputModes;
+  auto LockedInput(LockedInputModes) -> void;
+
   auto QueueRepeatMode() -> uint8_t;
   auto QueueRepeatMode(uint8_t) -> void;
 
@@ -167,6 +175,7 @@ class NvsStorage {
   Setting<uint16_t> amp_cur_vol_;
   Setting<int8_t> amp_left_bias_;
   Setting<uint8_t> input_mode_;
+  Setting<uint8_t> locked_input_mode_;
   Setting<uint8_t> output_mode_;
 
   Setting<std::string> theme_;

src/drivers/nvs.cpp

@@ -34,6 +34,7 @@ static constexpr char kKeyAmpMaxVolume[] = "hp_vol_max";
 static constexpr char kKeyAmpCurrentVolume[] = "hp_vol";
 static constexpr char kKeyAmpLeftBias[] = "hp_bias";
 static constexpr char kKeyPrimaryInput[] = "in_pri";
+static constexpr char kKeyLockedInput[] = "in_locked";
 static constexpr char kKeyScrollSensitivity[] = "scroll";
 static constexpr char kKeyLockPolarity[] = "lockpol";
 static constexpr char kKeyDisplayCols[] = "dispcols";
@@ -272,6 +273,7 @@ NvsStorage::NvsStorage(nvs_handle_t handle)
       amp_cur_vol_(kKeyAmpCurrentVolume),
       amp_left_bias_(kKeyAmpLeftBias),
       input_mode_(kKeyPrimaryInput),
+      locked_input_mode_(kKeyLockedInput),
       output_mode_(kKeyOutput),
       theme_{kKeyInterfaceTheme},
       bt_preferred_(kKeyBluetoothPreferred),
@@ -300,6 +302,7 @@ auto NvsStorage::Read() -> void {
   amp_cur_vol_.read(handle_);
   amp_left_bias_.read(handle_);
   input_mode_.read(handle_);
+  locked_input_mode_.read(handle_);
   output_mode_.read(handle_);
   theme_.read(handle_);
   bt_preferred_.read(handle_);
@@ -323,6 +326,7 @@ auto NvsStorage::Write() -> bool {
   amp_cur_vol_.write(handle_);
   amp_left_bias_.write(handle_);
   input_mode_.write(handle_);
+  locked_input_mode_.write(handle_);
   output_mode_.write(handle_);
   theme_.write(handle_);
   bt_preferred_.write(handle_);
@@ -570,6 +574,23 @@ auto NvsStorage::PrimaryInput(InputModes mode) -> void {
   input_mode_.set(static_cast<uint8_t>(mode));
 }
 
+auto NvsStorage::LockedInput() -> LockedInputModes {
+  std::lock_guard<std::mutex> lock{mutex_};
+  switch (locked_input_mode_.get().value_or(static_cast<uint8_t>(LockedInputModes::kDisabled))) {
+    case static_cast<uint8_t>(LockedInputModes::kDisabled):
+      return LockedInputModes::kDisabled;
+    case static_cast<uint8_t>(LockedInputModes::kVolumeOnly):
+      return LockedInputModes::kVolumeOnly;
+    default:
+      return LockedInputModes::kDisabled;
+  }
+}
+
+auto NvsStorage::LockedInput(LockedInputModes mode) -> void {
+  std::lock_guard<std::mutex> lock{mutex_};
+  locked_input_mode_.set(static_cast<uint8_t>(mode));
+}
+
 auto NvsStorage::QueueRepeatMode() -> uint8_t {
   std::lock_guard<std::mutex> lock{mutex_};
   return queue_repeat_mode_.get().value_or(0);

src/tangara/input/input_device.hpp

@@ -10,6 +10,7 @@
 #include <string>
 #include <vector>
 
+#include "drivers/nvs.hpp"
 #include "indev/lv_indev.h"
 #include "input/input_hook.hpp"
 #include "lua/property.hpp"
@@ -34,7 +35,7 @@ class IInputDevice {
   }
 
   /* Called by the LVGL driver when controls are being locked. */
-  virtual auto onLock() -> void {}
+  virtual auto onLock(drivers::NvsStorage::LockedInputModes) -> void {}
   /* Called by the LVGL driver when controls are being unlocked. */
   virtual auto onUnlock() -> void {}
 };

src/tangara/input/input_nav_buttons.cpp

@@ -42,7 +42,7 @@ auto NavButtons::triggers()
   return {up_, down_};
 }
 
-auto NavButtons::onLock() -> void {
+auto NavButtons::onLock(drivers::NvsStorage::LockedInputModes mode) -> void {
   locked_ = true;
 }
 

src/tangara/input/input_nav_buttons.hpp

@@ -28,7 +28,7 @@ class NavButtons : public IInputDevice {
   auto name() -> std::string override;
   auto triggers() -> std::vector<std::reference_wrapper<TriggerHooks>> override;
 
-  auto onLock() -> void override;
+  auto onLock(drivers::NvsStorage::LockedInputModes) -> void override;
   auto onUnlock() -> void override;
 
  private:

src/tangara/input/input_touch_dpad.cpp

@@ -65,7 +65,7 @@ auto TouchDPad::triggers()
   return {centre_, up_, right_, down_, left_};
 }
 
-auto TouchDPad::onLock() -> void {
+auto TouchDPad::onLock(drivers::NvsStorage::LockedInputModes mode) -> void {
   wheel_.LowPowerMode(true);
   locked_ = true;
 }

src/tangara/input/input_touch_dpad.hpp

@@ -27,7 +27,7 @@ class TouchDPad : public IInputDevice {
   auto name() -> std::string override;
   auto triggers() -> std::vector<std::reference_wrapper<TriggerHooks>> override;
 
-  auto onLock() -> void override;
+  auto onLock(drivers::NvsStorage::LockedInputModes) -> void override;
   auto onUnlock() -> void override;
 
  private:

src/tangara/input/input_touch_wheel.cpp

@@ -124,7 +124,7 @@ auto TouchWheel::triggers()
   return {centre_, up_, right_, down_, left_};
 }
 
-auto TouchWheel::onLock() -> void {
+auto TouchWheel::onLock(drivers::NvsStorage::LockedInputModes mode) -> void {
   wheel_.LowPowerMode(true);
   locked_ = true;
 }

src/tangara/input/input_touch_wheel.hpp

@@ -30,7 +30,7 @@ class TouchWheel : public IInputDevice {
   auto name() -> std::string override;
   auto triggers() -> std::vector<std::reference_wrapper<TriggerHooks>> override;
 
-  auto onLock() -> void override;
+  auto onLock(drivers::NvsStorage::LockedInputModes) -> void override;
   auto onUnlock() -> void override;
 
   auto sensitivity() -> lua::Property&;

src/tangara/input/input_volume_buttons.cpp

@@ -15,13 +15,15 @@ VolumeButtons::VolumeButtons(drivers::IGpios& gpios)
     : gpios_(gpios),
       up_("upper", actions::volumeUp()),
       down_("lower", actions::volumeDown()),
-      locked_(false) {}
+      locked_() {}
 
 auto VolumeButtons::read(lv_indev_data_t* data) -> void {
   bool up = !gpios_.Get(drivers::IGpios::Pin::kKeyUp);
   bool down = !gpios_.Get(drivers::IGpios::Pin::kKeyDown);
 
-  if ((up && down) || locked_) {
+  bool input_disabled = locked_.has_value() && (locked_ != drivers::NvsStorage::LockedInputModes::kVolumeOnly);
+
+  if ((up && down) || input_disabled) {
     up = false;
     down = false;
   }
@@ -39,12 +41,12 @@ auto VolumeButtons::triggers()
   return {up_, down_};
 }
 
-auto VolumeButtons::onLock() -> void {
-  locked_ = true;
+auto VolumeButtons::onLock(drivers::NvsStorage::LockedInputModes mode) -> void {
+  locked_ = mode;
 }
 
 auto VolumeButtons::onUnlock() -> void {
-  locked_ = false;
+  locked_ = {};
 }
 
 }  // namespace input

src/tangara/input/input_volume_buttons.hpp

@@ -27,7 +27,7 @@ class VolumeButtons : public IInputDevice {
   auto name() -> std::string override;
   auto triggers() -> std::vector<std::reference_wrapper<TriggerHooks>> override;
 
-  auto onLock() -> void override;
+  auto onLock(drivers::NvsStorage::LockedInputModes) -> void override;
   auto onUnlock() -> void override;
 
  private:
@@ -36,7 +36,8 @@ class VolumeButtons : public IInputDevice {
   TriggerHooks up_;
   TriggerHooks down_;
 
-  bool locked_;
+  // When locked, this contains the active mode
+  std::optional<drivers::NvsStorage::LockedInputModes> locked_;
 };
 
 }  // namespace input

src/tangara/input/lvgl_input_driver.cpp

@@ -53,6 +53,8 @@ static void focus_cb(lv_group_t* group) {
   instance->feedback(LV_EVENT_FOCUSED);
 }
 
+namespace {
+
 auto intToMode(int raw) -> std::optional<drivers::NvsStorage::InputModes> {
   switch (raw) {
     case 0:
@@ -68,6 +70,19 @@ auto intToMode(int raw) -> std::optional<drivers::NvsStorage::InputModes> {
   }
 }
 
+auto intToLockedMode(int raw) -> std::optional<drivers::NvsStorage::LockedInputModes> {
+  switch (raw) {
+    case 0:
+      return drivers::NvsStorage::LockedInputModes::kDisabled;
+    case 1:
+      return drivers::NvsStorage::LockedInputModes::kVolumeOnly;
+    default:
+      return {};
+  }
+}
+
+} // namespace {}
+
 LvglInputDriver::LvglInputDriver(drivers::NvsStorage& nvs,
                                  DeviceFactory& factory)
     : nvs_(nvs),
@@ -85,6 +100,18 @@ LvglInputDriver::LvglInputDriver(drivers::NvsStorage& nvs,
               inputs_ = factory.createInputs(*mode);
               return true;
             }),
+      locked_mode_(static_cast<int>(nvs.LockedInput()),
+            [&](const lua::LuaValue& val) {
+              if (!std::holds_alternative<int>(val)) {
+                return false;
+              }
+              auto mode = intToLockedMode(std::get<int>(val));
+              if (!mode) {
+                return false;
+              }
+              nvs.LockedInput(*mode);
+              return true;
+            }),
       inputs_(factory.createInputs(nvs.PrimaryInput())),
       feedbacks_(factory.createFeedbacks()),
       is_locked_(false) {
@@ -130,9 +157,11 @@ auto LvglInputDriver::feedback(uint8_t event) -> void {
 
 auto LvglInputDriver::lock(bool l) -> void {
   is_locked_ = l;
+  auto locked_input_mode = nvs_.LockedInput();
+
   for (auto&& device : inputs_) {
     if (l) {
-      device->onLock();
+      device->onLock(locked_input_mode);
     } else {
       device->onUnlock();
     }

src/tangara/input/lvgl_input_driver.hpp

@@ -36,6 +36,7 @@ class LvglInputDriver {
   LvglInputDriver(drivers::NvsStorage& nvs, DeviceFactory&);
 
   auto mode() -> lua::Property& { return mode_; }
+  auto lockedMode() -> lua::Property& { return locked_mode_; }
 
   auto setGroup(lv_group_t*) -> void;
   auto read(lv_indev_data_t* data) -> void;
@@ -49,6 +50,7 @@ class LvglInputDriver {
   DeviceFactory& factory_;
 
   lua::Property mode_;
+  lua::Property locked_mode_;
   lv_indev_t* device_;
 
   std::vector<std::shared_ptr<IInputDevice>> inputs_;

src/tangara/lua/lua_controls.cpp

@@ -42,7 +42,24 @@ static auto controls_schemes(lua_State* L) -> int {
   return 1;
 }
 
+static auto locked_controls_schemes(lua_State* L) -> int {
+  lua_newtable(L);
+
+  lua_pushliteral(L, "Disabled");
+  lua_rawseti(
+      L, -2,
+      static_cast<int>(drivers::NvsStorage::LockedInputModes::kDisabled));
+
+  lua_pushliteral(L, "Volume Only");
+  lua_rawseti(
+      L, -2,
+      static_cast<int>(drivers::NvsStorage::LockedInputModes::kVolumeOnly));
+
+  return 1;
+}
+
 static const struct luaL_Reg kControlsFuncs[] = {{"schemes", controls_schemes},
+                                                 {"locked_schemes", locked_controls_schemes},
                                                  {NULL, NULL}};
 
 static auto lua_controls(lua_State* state) -> int {

src/tangara/ui/ui_fsm.cpp

@@ -667,6 +667,7 @@ void Lua::entry() {
         "controls",
         {
             {"scheme", &sInput->mode()},
+            {"locked_scheme", &sInput->lockedMode()},
             {"lock_switch", &sLockSwitch},
             {"hooks", [&](lua_State* L) { return sInput->pushHooks(L); }},
         });