summaryrefslogtreecommitdiff
path: root/src/ui
diff options
context:
space:
mode:
Diffstat (limited to 'src/ui')
-rw-r--r--src/ui/include/screen.hpp10
-rw-r--r--src/ui/include/screen_playing.hpp36
-rw-r--r--src/ui/include/ui_fsm.hpp31
-rw-r--r--src/ui/screen_playing.cpp105
-rw-r--r--src/ui/ui_fsm.cpp60
5 files changed, 213 insertions, 29 deletions
diff --git a/src/ui/include/screen.hpp b/src/ui/include/screen.hpp
index 7ff06fbd..13b92a09 100644
--- a/src/ui/include/screen.hpp
+++ b/src/ui/include/screen.hpp
@@ -15,14 +15,24 @@
namespace ui {
+/*
+ * Base class for ever discrete screen in the app. Provides a consistent
+ * interface that can be used for transitioning between screens, adding them to
+ * back stacks, etc.
+ */
class Screen {
public:
Screen() : root_(lv_obj_create(NULL)), group_(lv_group_create()) {}
+
virtual ~Screen() {
lv_obj_del(root_);
lv_group_del(group_);
}
+ /*
+ * Called periodically to allow the screen to update itself, e.g. to handle
+ * std::futures that are still loading in.
+ */
virtual auto Tick() -> void {}
auto root() -> lv_obj_t* { return root_; }
diff --git a/src/ui/include/screen_playing.hpp b/src/ui/include/screen_playing.hpp
index 3eae32a7..148f2774 100644
--- a/src/ui/include/screen_playing.hpp
+++ b/src/ui/include/screen_playing.hpp
@@ -6,25 +6,55 @@
#pragma once
+#include <stdint.h>
+#include <sys/_stdint.h>
#include <memory>
+#include <vector>
#include "lvgl.h"
#include "database.hpp"
+#include "future_fetcher.hpp"
#include "screen.hpp"
+#include "track.hpp"
+#include "track_queue.hpp"
namespace ui {
namespace screens {
+/*
+ * The 'Now Playing' / 'Currently Playing' screen that contains information
+ * about the current track, as well as playback controls.
+ */
class Playing : public Screen {
public:
- explicit Playing(database::Track t);
+ explicit Playing(std::weak_ptr<database::Database> db,
+ audio::TrackQueue* queue);
~Playing();
- auto BindTrack(database::Track t) -> void;
+ auto Tick() -> void override;
+
+ // Callbacks invoked by the UI state machine in response to audio events.
+
+ auto OnTrackUpdate() -> void;
+ auto OnPlaybackUpdate(uint32_t, uint32_t) -> void;
+ auto OnQueueUpdate() -> void;
private:
- database::Track track_;
+ auto BindTrack(const database::Track& track) -> void;
+ auto ApplyNextUp(const std::vector<database::Track>& tracks) -> void;
+
+ std::weak_ptr<database::Database> db_;
+ audio::TrackQueue* queue_;
+
+ std::optional<database::Track> track_;
+ std::vector<database::Track> next_tracks_;
+
+ std::unique_ptr<database::FutureFetcher<std::optional<database::Track>>>
+ new_track_;
+ std::unique_ptr<
+ database::FutureFetcher<std::vector<std::optional<database::Track>>>>
+ new_next_tracks_;
lv_obj_t* artist_label_;
lv_obj_t* album_label_;
diff --git a/src/ui/include/ui_fsm.hpp b/src/ui/include/ui_fsm.hpp
index 32275fab..2fc6db4e 100644
--- a/src/ui/include/ui_fsm.hpp
+++ b/src/ui/include/ui_fsm.hpp
@@ -9,7 +9,9 @@
#include <memory>
#include <stack>
+#include "audio_events.hpp"
#include "relative_wheel.hpp"
+#include "screen_playing.hpp"
#include "tinyfsm.hpp"
#include "display.hpp"
@@ -17,13 +19,14 @@
#include "storage.hpp"
#include "system_events.hpp"
#include "touchwheel.hpp"
+#include "track_queue.hpp"
#include "ui_events.hpp"
namespace ui {
class UiState : public tinyfsm::Fsm<UiState> {
public:
- static auto Init(drivers::IGpios* gpio_expander) -> bool;
+ static auto Init(drivers::IGpios*, audio::TrackQueue*) -> bool;
virtual ~UiState() {}
@@ -37,10 +40,14 @@ class UiState : public tinyfsm::Fsm<UiState> {
/* Fallback event handler. Does nothing. */
void react(const tinyfsm::Event& ev) {}
- virtual void react(const system_fsm::KeyLockChanged&){};
+ virtual void react(const audio::PlaybackStarted&) {}
+ virtual void react(const audio::PlaybackUpdate&) {}
+ virtual void react(const audio::QueueUpdate&) {}
- virtual void react(const internal::RecordSelected&){};
- virtual void react(const internal::IndexSelected&){};
+ virtual void react(const system_fsm::KeyLockChanged&) {}
+
+ virtual void react(const internal::RecordSelected&) {}
+ virtual void react(const internal::IndexSelected&) {}
virtual void react(const system_fsm::DisplayReady&) {}
virtual void react(const system_fsm::BootComplete&) {}
@@ -48,8 +55,11 @@ class UiState : public tinyfsm::Fsm<UiState> {
protected:
void PushScreen(std::shared_ptr<Screen>);
+ void PopScreen();
static drivers::IGpios* sIGpios;
+ static audio::TrackQueue* sQueue;
+
static std::shared_ptr<drivers::TouchWheel> sTouchWheel;
static std::shared_ptr<drivers::RelativeWheel> sRelativeWheel;
static std::shared_ptr<drivers::Display> sDisplay;
@@ -68,7 +78,7 @@ class Splash : public UiState {
using UiState::react;
};
-class Interactive : public UiState {
+class Browse : public UiState {
void entry() override;
void react(const internal::RecordSelected&) override;
@@ -76,6 +86,17 @@ class Interactive : public UiState {
void react(const system_fsm::KeyLockChanged&) override;
void react(const system_fsm::StorageMounted&) override;
+ using UiState::react;
+};
+
+class Playing : public UiState {
+ void entry() override;
+ void exit() override;
+
+ void react(const audio::PlaybackStarted&) override;
+ void react(const audio::PlaybackUpdate&) override;
+ void react(const audio::QueueUpdate&) override;
+ using UiState::react;
};
class FatalError : public UiState {};
diff --git a/src/ui/screen_playing.cpp b/src/ui/screen_playing.cpp
index 1ac8ad5a..50b1d33a 100644
--- a/src/ui/screen_playing.cpp
+++ b/src/ui/screen_playing.cpp
@@ -5,12 +5,17 @@
*/
#include "screen_playing.hpp"
+#include <sys/_stdint.h>
+#include <memory>
#include "core/lv_obj.h"
+#include "core/lv_obj_tree.h"
+#include "database.hpp"
#include "esp_log.h"
#include "extra/layouts/flex/lv_flex.h"
#include "extra/layouts/grid/lv_grid.h"
#include "font/lv_symbol_def.h"
+#include "future_fetcher.hpp"
#include "lvgl.h"
#include "core/lv_group.h"
@@ -19,8 +24,10 @@
#include "extra/widgets/list/lv_list.h"
#include "extra/widgets/menu/lv_menu.h"
#include "extra/widgets/spinner/lv_spinner.h"
+#include "future_fetcher.hpp"
#include "hal/lv_hal_disp.h"
#include "index.hpp"
+#include "misc/lv_anim.h"
#include "misc/lv_area.h"
#include "misc/lv_color.h"
#include "track.hpp"
@@ -34,6 +41,8 @@
namespace ui {
namespace screens {
+static constexpr std::size_t kMaxUpcoming = 10;
+
static lv_style_t scrubber_style;
auto info_label(lv_obj_t* parent) -> lv_obj_t* {
@@ -59,7 +68,13 @@ auto next_up_label(lv_obj_t* parent, const std::string& text) -> lv_obj_t* {
return label;
}
-Playing::Playing(database::Track track) : track_(track) {
+Playing::Playing(std::weak_ptr<database::Database> db, audio::TrackQueue* queue)
+ : db_(db),
+ queue_(queue),
+ track_(),
+ next_tracks_(),
+ new_track_(),
+ new_next_tracks_() {
lv_obj_set_layout(root_, LV_LAYOUT_FLEX);
lv_obj_set_size(root_, lv_pct(100), lv_pct(200));
lv_obj_set_flex_flow(root_, LV_FLEX_FLOW_COLUMN);
@@ -130,17 +145,72 @@ Playing::Playing(database::Track track) : track_(track) {
lv_obj_set_flex_align(next_up_container_, LV_FLEX_ALIGN_CENTER,
LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_END);
- lv_group_add_obj(group_, next_up_label(root_, "Song 2"));
- lv_group_add_obj(group_, next_up_label(root_, "Song 3"));
- lv_group_add_obj(
- group_, next_up_label(root_, "Another song that has a very long name"));
-
- BindTrack(track);
+ OnTrackUpdate();
+ OnQueueUpdate();
}
Playing::~Playing() {}
-auto Playing::BindTrack(database::Track t) -> void {
+auto Playing::OnTrackUpdate() -> void {
+ auto current = queue_->GetCurrent();
+ if (!current) {
+ return;
+ }
+ if (track_ && track_->data().id() == *current) {
+ return;
+ }
+ auto db = db_.lock();
+ if (!db) {
+ return;
+ }
+ new_track_.reset(new database::FutureFetcher<std::optional<database::Track>>(
+ db->GetTrack(*current)));
+}
+
+auto Playing::OnPlaybackUpdate(uint32_t pos_seconds, uint32_t new_duration)
+ -> void {
+ if (!track_) {
+ return;
+ }
+ lv_bar_set_range(scrubber_, 0, new_duration);
+ lv_bar_set_value(scrubber_, pos_seconds, LV_ANIM_ON);
+}
+
+auto Playing::OnQueueUpdate() -> void {
+ auto current = queue_->GetUpcoming(kMaxUpcoming);
+ auto db = db_.lock();
+ if (!db) {
+ return;
+ }
+ new_next_tracks_.reset(
+ new database::FutureFetcher<std::vector<std::optional<database::Track>>>(
+ db->GetBulkTracks(current)));
+}
+
+auto Playing::Tick() -> void {
+ if (new_track_ && new_track_->Finished()) {
+ auto res = new_track_->Result();
+ new_track_.reset();
+ if (res && *res) {
+ BindTrack(**res);
+ }
+ }
+ if (new_next_tracks_ && new_next_tracks_->Finished()) {
+ auto res = new_next_tracks_->Result();
+ new_next_tracks_.reset();
+ if (res) {
+ std::vector<database::Track> filtered;
+ for (const auto& t : *res) {
+ if (t) {
+ filtered.push_back(*t);
+ }
+ }
+ ApplyNextUp(filtered);
+ }
+ }
+}
+
+auto Playing::BindTrack(const database::Track& t) -> void {
track_ = t;
lv_label_set_text(artist_label_,
@@ -148,6 +218,25 @@ auto Playing::BindTrack(database::Track t) -> void {
lv_label_set_text(album_label_,
t.tags().at(database::Tag::kAlbum).value_or("").c_str());
lv_label_set_text(title_label_, t.TitleOrFilename().c_str());
+
+ std::optional<int> duration = t.tags().duration;
+ lv_bar_set_range(scrubber_, 0, duration.value_or(1));
+ lv_bar_set_value(scrubber_, 0, LV_ANIM_OFF);
+}
+
+auto Playing::ApplyNextUp(const std::vector<database::Track>& tracks) -> void {
+ // TODO(jacqueline): Do a proper diff to maintain selection.
+ int children = lv_obj_get_child_cnt(next_up_container_);
+ while (children > 0) {
+ lv_obj_del(lv_obj_get_child(next_up_container_, 0));
+ children--;
+ }
+
+ next_tracks_ = tracks;
+ for (const auto& track : next_tracks_) {
+ lv_group_add_obj(
+ group_, next_up_label(next_up_container_, track.TitleOrFilename()));
+ }
}
} // namespace screens
diff --git a/src/ui/ui_fsm.cpp b/src/ui/ui_fsm.cpp
index 58b1f641..5394311c 100644
--- a/src/ui/ui_fsm.cpp
+++ b/src/ui/ui_fsm.cpp
@@ -19,6 +19,7 @@
#include "screen_track_browser.hpp"
#include "system_events.hpp"
#include "touchwheel.hpp"
+#include "track_queue.hpp"
namespace ui {
@@ -27,6 +28,8 @@ static constexpr char kTag[] = "ui_fsm";
static const std::size_t kRecordsPerPage = 10;
drivers::IGpios* UiState::sIGpios;
+audio::TrackQueue* UiState::sQueue;
+
std::shared_ptr<drivers::TouchWheel> UiState::sTouchWheel;
std::shared_ptr<drivers::RelativeWheel> UiState::sRelativeWheel;
std::shared_ptr<drivers::Display> UiState::sDisplay;
@@ -35,8 +38,10 @@ std::weak_ptr<database::Database> UiState::sDb;
std::stack<std::shared_ptr<Screen>> UiState::sScreens;
std::shared_ptr<Screen> UiState::sCurrentScreen;
-auto UiState::Init(drivers::IGpios* gpio_expander) -> bool {
+auto UiState::Init(drivers::IGpios* gpio_expander, audio::TrackQueue* queue)
+ -> bool {
sIGpios = gpio_expander;
+ sQueue = queue;
lv_init();
sDisplay.reset(
@@ -69,6 +74,14 @@ void UiState::PushScreen(std::shared_ptr<Screen> screen) {
sCurrentScreen = screen;
}
+void UiState::PopScreen() {
+ if (sScreens.empty()) {
+ return;
+ }
+ sCurrentScreen = sScreens.top();
+ sScreens.pop();
+}
+
namespace states {
void Splash::exit() {
@@ -78,16 +91,16 @@ void Splash::exit() {
}
void Splash::react(const system_fsm::BootComplete& ev) {
- transit<Interactive>();
+ transit<Browse>();
}
-void Interactive::entry() {}
+void Browse::entry() {}
-void Interactive::react(const system_fsm::KeyLockChanged& ev) {
+void Browse::react(const system_fsm::KeyLockChanged& ev) {
sDisplay->SetDisplayOn(ev.falling);
}
-void Interactive::react(const system_fsm::StorageMounted& ev) {
+void Browse::react(const system_fsm::StorageMounted& ev) {
sDb = ev.db;
auto db = ev.db.lock();
if (!db) {
@@ -97,7 +110,7 @@ void Interactive::react(const system_fsm::StorageMounted& ev) {
PushScreen(std::make_shared<screens::Menu>(db->GetIndexes()));
}
-void Interactive::react(const internal::RecordSelected& ev) {
+void Browse::react(const internal::RecordSelected& ev) {
auto db = sDb.lock();
if (!db) {
return;
@@ -106,12 +119,9 @@ void Interactive::react(const internal::RecordSelected& ev) {
if (ev.record.track()) {
ESP_LOGI(kTag, "selected track '%s'", ev.record.text()->c_str());
// TODO(jacqueline): We should also send some kind of playlist info here.
- auto track = ev.record.track().value();
- events::Dispatch<audio::PlayTrack, audio::AudioState>(audio::PlayTrack{
- .id = track.data().id(),
- .data = track.data(),
- });
- PushScreen(std::make_shared<screens::Playing>(track));
+ sQueue->Clear();
+ sQueue->AddLast(ev.record.track()->data().id());
+ transit<Playing>();
} else {
ESP_LOGI(kTag, "selected record '%s'", ev.record.text()->c_str());
auto cont = ev.record.Expand(kRecordsPerPage);
@@ -125,7 +135,7 @@ void Interactive::react(const internal::RecordSelected& ev) {
}
}
-void Interactive::react(const internal::IndexSelected& ev) {
+void Browse::react(const internal::IndexSelected& ev) {
auto db = sDb.lock();
if (!db) {
return;
@@ -137,6 +147,30 @@ void Interactive::react(const internal::IndexSelected& ev) {
std::move(query)));
}
+static std::shared_ptr<screens::Playing> sPlayingScreen;
+
+void Playing::entry() {
+ sPlayingScreen.reset(new screens::Playing(sDb, sQueue));
+ PushScreen(sPlayingScreen);
+}
+
+void Playing::exit() {
+ sPlayingScreen.reset();
+ PopScreen();
+}
+
+void Playing::react(const audio::PlaybackStarted& ev) {
+ sPlayingScreen->OnTrackUpdate();
+}
+
+void Playing::react(const audio::PlaybackUpdate& ev) {
+ sPlayingScreen->OnPlaybackUpdate(ev.seconds_elapsed, ev.seconds_total);
+}
+
+void Playing::react(const audio::QueueUpdate& ev) {
+ sPlayingScreen->OnQueueUpdate();
+}
+
} // namespace states
} // namespace ui
generated by cgit v1.2.3 (git 2.25.1) at 2026-04-30 01:07:35 +0000