Merge branch 'main' into playlist-browser

.gitignore

@@ -12,6 +12,7 @@ sdkconfig.old
 .vscode
 compile_commands.json
 warnings.txt
+.DS_Store
 
 doc/
 

lua/main_menu.lua

@@ -55,7 +55,6 @@ return widgets.MenuScreen:new {
 
     now_playing:onClicked(function() backstack.push(playing:new()) end)
 
-    local has_focus = false
     local track_duration = nil
 
     self.bindings = self.bindings + {
@@ -71,7 +70,6 @@ return widgets.MenuScreen:new {
           now_playing:add_flag(lvgl.FLAG.HIDDEN)
           return
         else
-          has_focus = true
           now_playing:clear_flag(lvgl.FLAG.HIDDEN)
         end
         title:set { text = track.title }
@@ -148,6 +146,10 @@ return widgets.MenuScreen:new {
     local function hide_no_indexes()
       no_indexes_container:add_flag(lvgl.FLAG.HIDDEN)
       indexes_list:clear_flag(lvgl.FLAG.HIDDEN)
+
+      if indexes[1] then
+        indexes[1].object:focus()
+      end
     end
 
     local function hide_playlist_listing()

lua/playing.lua

@@ -276,7 +276,7 @@ return screen:new {
           if queue.loading:get() then
             title:set { text = "Loading..." }
           else
-            title:set{text=""}
+            title:set{ text = "Not Playing" }
           end
           album:set{text=""}
           artist:set{text=""}

lua/settings.lua

@@ -93,6 +93,7 @@ settings.BluetoothSettings = SettingsScreen:new {
       local enabled = enable_sw:enabled()
       bluetooth.enabled:set(enabled)
     end)
+    enable_sw:focus()
 
     self.bindings = self.bindings + {
       bluetooth.enabled:bind(function(en)
@@ -232,6 +233,7 @@ settings.HeadphonesSettings = SettingsScreen:new {
       local selection = volume_chooser:get('selected') + 1
       volume.limit_db:set(limits[selection])
     end)
+    volume_chooser:focus()
 
     theme.set_subject(self.content:Label {
       text = "Left/Right balance",
@@ -304,6 +306,7 @@ settings.DisplaySettings = SettingsScreen:new {
     brightness:onevent(lvgl.EVENT.VALUE_CHANGED, function()
       display.brightness:set(brightness:value())
     end)
+    brightness:focus()
 
     self.bindings = self.bindings + {
       display.brightness:bind(function(b)
@@ -372,6 +375,8 @@ settings.ThemeSettings = SettingsScreen:new {
         backstack.reset(main_menu:new())
       end
     end)
+
+    theme_chooser:focus()
   end
 }
 
@@ -380,44 +385,62 @@ 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)
+
+        return controls_chooser
     end
 
-    local controls_chooser = self.content:Dropdown {
-      options = options,
-      symbol = img.chevron,
-    }
+    theme.set_subject(self.content:Label {
+      text = "Control scheme",
+    }, "settings_title")
+    local controls_chooser = 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)
-    }
+    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:onevent(lvgl.EVENT.VALUE_CHANGED, function()
-      local option = controls_chooser:get('selected')
-      local scheme = option_to_scheme[option]
-      controls.scheme:set(scheme)
-    end)
+    controls_chooser:focus()
 
     theme.set_subject(self.content:Label {
       text = "Scroll Sensitivity",
@@ -483,6 +506,7 @@ settings.MassStorageSettings = SettingsScreen:new {
       end
       bind_switch()
     end)
+    enable_sw:focus()
 
     self.bindings = self.bindings + {
       usb.msc_enabled:bind(bind_switch),
@@ -560,6 +584,7 @@ settings.DatabaseSettings = SettingsScreen:new {
     update:onClicked(function()
       database.update()
     end)
+    update:focus()
 
     self.bindings = self.bindings + {
       database.auto_update:bind(function(en)
@@ -841,10 +866,11 @@ settings.Root = widgets.MenuScreen:new {
          end)
       end
       item:add_style(styles.list_item)
+      return item
     end
 
     local audio_section = section("Audio")
-    submenu("Bluetooth", settings.BluetoothSettings, audio_section)
+    local first_item = submenu("Bluetooth", settings.BluetoothSettings, audio_section)
     submenu("Headphones", settings.HeadphonesSettings)
 
     section("Interface")
@@ -863,6 +889,8 @@ settings.Root = widgets.MenuScreen:new {
     submenu("Firmware", settings.FirmwareSettings)
     submenu("Licenses", settings.LicensesScreen)
     submenu("Regulatory", settings.RegulatoryScreen)
+
+    first_item:focus()
   end
 }
 

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

@@ -21,6 +21,8 @@
 #include "lua/property.hpp"
 #include "ui/ui_events.hpp"
 
+#include "esp_timer.h"
+
 namespace input {
 
 TouchWheel::TouchWheel(drivers::NvsStorage& nvs, drivers::TouchWheel& wheel)
@@ -77,7 +79,16 @@ auto TouchWheel::read(lv_indev_data_t* data) -> void {
     data->enc_diff = 0;
   }
 
-  centre_.update(wheel_data.is_button_touched && !wheel_data.is_wheel_touched,
+  // Prevent accidental center button touches while scrolling
+  if (wheel_data.is_wheel_touched) {
+    last_wheel_touch_time_ = esp_timer_get_time();
+  }
+
+  bool wheel_touch_timed_out =
+      esp_timer_get_time() - last_wheel_touch_time_ > SCROLL_TIMEOUT_US;
+
+  centre_.update(wheel_touch_timed_out && wheel_data.is_button_touched &&
+                     !wheel_data.is_wheel_touched,
                  data);
 
   // If the user is touching the wheel but not scrolling, then they may be
@@ -113,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,12 +30,14 @@ 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&;
 
  private:
+  const int64_t SCROLL_TIMEOUT_US = 250000;  // 250ms
+
   auto calculateTicks(const drivers::TouchWheelData& data) -> int8_t;
   auto calculateThreshold(uint8_t sensitivity) -> uint8_t;
 
@@ -55,6 +57,7 @@ class TouchWheel : public IInputDevice {
   uint8_t threshold_;
   bool is_first_read_;
   uint8_t last_angle_;
+  int64_t last_wheel_touch_time_;
 };
 
 }  // namespace input

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