wire up the playing screen with some real data

Includes implementing song duration calculation for CBR MP3 files

3 files changed, 56 insertions, 13 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 5ccfe391..148f2774 100644
--- a/src/ui/include/screen_playing.hpp
+++ b/src/ui/include/screen_playing.hpp
@@ -7,30 +7,54 @@
 #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;
 
-  auto UpdateTime(uint32_t) -> void;
-  auto UpdateNextUp(std::vector<database::Track> tracks) -> void;
+  // 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_;
@@ -40,7 +64,6 @@ class Playing : public Screen {
   lv_obj_t* play_pause_control_;
 
   lv_obj_t* next_up_container_;
-  std::vector<database::Track> next_tracks_;
 };
 
 }  // namespace screens
diff --git a/src/ui/include/ui_fsm.hpp b/src/ui/include/ui_fsm.hpp
index cd1ec492..2fc6db4e 100644
--- a/src/ui/include/ui_fsm.hpp
+++ b/src/ui/include/ui_fsm.hpp
@@ -19,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() {}
 
@@ -39,12 +40,14 @@ class UiState : public tinyfsm::Fsm<UiState> {
   /* Fallback event handler. Does nothing. */
   void react(const tinyfsm::Event& ev) {}
 
-  virtual void react(const audio::PlaybackUpdate){};
+  virtual void react(const audio::PlaybackStarted&) {}
+  virtual void react(const audio::PlaybackUpdate&) {}
+  virtual void react(const audio::QueueUpdate&) {}
 
-  virtual void react(const system_fsm::KeyLockChanged&){};
+  virtual void react(const system_fsm::KeyLockChanged&) {}
 
-  virtual void react(const internal::RecordSelected&){};
-  virtual void react(const internal::IndexSelected&){};
+  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&) {}
@@ -52,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;
@@ -61,7 +67,6 @@ class UiState : public tinyfsm::Fsm<UiState> {
 
   static std::stack<std::shared_ptr<Screen>> sScreens;
   static std::shared_ptr<Screen> sCurrentScreen;
-  static std::unique_ptr<screens::Playing> sPlayingScreen;
 };
 
 namespace states {
@@ -81,12 +86,17 @@ class Browse : 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::PlaybackUpdate) 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 {};