Add optional support for changing volume while locked

This adds a new Controls setting for adjusting the behavior
when locked, and an option for allowing volume control.

lua/settings.lua

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

src/drivers/include/drivers/nvs.hpp

@@ -140,6 +140,7 @@ class NvsStorage {
 
   enum class LockedInputModes : uint8_t {
     kDisabled = 0,
+    kVolumeOnly = 1,
   };
 
   auto LockedInput() -> LockedInputModes;

src/drivers/nvs.cpp

@@ -574,9 +574,11 @@ auto NvsStorage::PrimaryInput(InputModes mode) -> void {
 
 auto NvsStorage::LockedInput() -> LockedInputModes {
   std::lock_guard<std::mutex> lock{mutex_};
-  switch (input_mode_.get().value_or(static_cast<uint8_t>(LockedInputModes::kDisabled))) {
+  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;
   }

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;
   }
@@ -40,11 +42,11 @@ auto VolumeButtons::triggers()
 }
 
 auto VolumeButtons::onLock(drivers::NvsStorage::LockedInputModes mode) -> void {
-  locked_ = true;
+  locked_ = mode;
 }
 
 auto VolumeButtons::onUnlock() -> void {
-  locked_ = false;
+  locked_ = {};
 }
 
 }  // namespace input

src/tangara/input/input_volume_buttons.hpp

@@ -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

@@ -74,6 +74,8 @@ auto intToLockedMode(int raw) -> std::optional<drivers::NvsStorage::LockedInputM
   switch (raw) {
     case 0:
       return drivers::NvsStorage::LockedInputModes::kDisabled;
+    case 1:
+      return drivers::NvsStorage::LockedInputModes::kVolumeOnly;
     default:
       return {};
   }

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); }},
         });