Use a service locator instead of passing around subsets of drivers between FSMs

6 files changed, 41 insertions, 66 deletions

diff --git a/src/audio/audio_fsm.cpp b/src/audio/audio_fsm.cpp
index 6cca8211..9121cb5a 100644
--- a/src/audio/audio_fsm.cpp
+++ b/src/audio/audio_fsm.cpp
@@ -25,6 +25,7 @@
 #include "future_fetcher.hpp"
 #include "i2s_audio_output.hpp"
 #include "i2s_dac.hpp"
+#include "service_locator.hpp"
 #include "system_events.hpp"
 #include "track.hpp"
 #include "track_queue.hpp"
@@ -33,49 +34,15 @@ namespace audio {
 
 static const char kTag[] = "audio_fsm";
 
-drivers::IGpios* AudioState::sIGpios;
-std::shared_ptr<drivers::I2SDac> AudioState::sDac;
-std::weak_ptr<database::Database> AudioState::sDatabase;
+std::shared_ptr<system_fsm::ServiceLocator> AudioState::sServices;
 
 std::shared_ptr<FatfsAudioInput> AudioState::sFileSource;
 std::unique_ptr<Decoder> AudioState::sDecoder;
 std::shared_ptr<SampleConverter> AudioState::sSampleConverter;
 std::shared_ptr<IAudioOutput> AudioState::sOutput;
 
-TrackQueue* AudioState::sTrackQueue;
 std::optional<database::TrackId> AudioState::sCurrentTrack;
 
-auto AudioState::Init(drivers::IGpios* gpio_expander,
-                      std::weak_ptr<database::Database> database,
-                      std::shared_ptr<database::ITagParser> tag_parser,
-                      drivers::Bluetooth* bluetooth,
-                      TrackQueue* queue) -> bool {
-  sIGpios = gpio_expander;
-  sTrackQueue = queue;
-
-  auto dac = drivers::I2SDac::create(gpio_expander);
-  if (!dac) {
-    return false;
-  }
-  sDac.reset(dac.value());
-  sDatabase = database;
-
-  sFileSource.reset(new FatfsAudioInput(tag_parser));
-  sOutput.reset(new I2SAudioOutput(sIGpios, sDac));
-  // sOutput.reset(new BluetoothAudioOutput(bluetooth));
-
-  sSampleConverter.reset(new SampleConverter());
-  sSampleConverter->SetOutput(sOutput);
-
-  Decoder::Start(sFileSource, sSampleConverter);
-
-  return true;
-}
-
-void AudioState::react(const system_fsm::StorageMounted& ev) {
-  sDatabase = ev.db;
-}
-
 void AudioState::react(const system_fsm::KeyUpChanged& ev) {
   if (ev.falling && sOutput->AdjustVolumeUp()) {
     ESP_LOGI(kTag, "volume up!");
@@ -100,7 +67,26 @@ void AudioState::react(const system_fsm::HasPhonesChanged& ev) {
 
 namespace states {
 
-void Uninitialised::react(const system_fsm::BootComplete&) {
+void Uninitialised::react(const system_fsm::BootComplete& ev) {
+  sServices = ev.services;
+
+  auto dac = drivers::I2SDac::create(sServices->gpios());
+  if (!dac) {
+    events::System().Dispatch(system_fsm::FatalError{});
+    events::Ui().Dispatch(system_fsm::FatalError{});
+    return;
+  }
+
+  sFileSource.reset(new FatfsAudioInput(sServices->tag_parser()));
+  sOutput.reset(new I2SAudioOutput(sServices->gpios(),
+                                   std::unique_ptr<drivers::I2SDac>{*dac}));
+  // sOutput.reset(new BluetoothAudioOutput(bluetooth));
+
+  sSampleConverter.reset(new SampleConverter());
+  sSampleConverter->SetOutput(sOutput);
+
+  Decoder::Start(sFileSource, sSampleConverter);
+
   transit<Standby>();
 }
 
@@ -117,19 +103,18 @@ void Standby::react(const internal::InputFileOpened& ev) {
 }
 
 void Standby::react(const QueueUpdate& ev) {
-  auto current_track = sTrackQueue->GetCurrent();
+  auto current_track = sServices->track_queue().GetCurrent();
   if (!current_track || (sCurrentTrack && *sCurrentTrack == *current_track)) {
     return;
   }
 
   sCurrentTrack = current_track;
 
-  auto db = sDatabase.lock();
+  auto db = sServices->database().lock();
   if (!db) {
     ESP_LOGW(kTag, "database not open; ignoring play request");
     return;
   }
-
   sFileSource->SetPath(db->GetTrackPath(*current_track));
 }
 
@@ -158,7 +143,7 @@ void Playback::react(const QueueUpdate& ev) {
   if (!ev.current_changed) {
     return;
   }
-  auto current_track = sTrackQueue->GetCurrent();
+  auto current_track = sServices->track_queue().GetCurrent();
   if (!current_track) {
     sFileSource->SetPath();
     sCurrentTrack.reset();
@@ -168,7 +153,7 @@ void Playback::react(const QueueUpdate& ev) {
 
   sCurrentTrack = current_track;
 
-  auto db = sDatabase.lock();
+  auto db = sServices->database().lock();
   if (!db) {
     return;
   }
@@ -191,8 +176,8 @@ void Playback::react(const internal::InputFileClosed& ev) {}
 
 void Playback::react(const internal::InputFileFinished& ev) {
   ESP_LOGI(kTag, "finished playing file");
-  sTrackQueue->Next();
-  if (!sTrackQueue->GetCurrent()) {
+  sServices->track_queue().Next();
+  if (!sServices->track_queue().GetCurrent()) {
     transit<Standby>();
   }
 }
diff --git a/src/audio/fatfs_audio_input.cpp b/src/audio/fatfs_audio_input.cpp
index 44653624..6b032632 100644
--- a/src/audio/fatfs_audio_input.cpp
+++ b/src/audio/fatfs_audio_input.cpp
@@ -40,8 +40,7 @@ static const char* kTag = "SRC";
 
 namespace audio {
 
-FatfsAudioInput::FatfsAudioInput(
-    std::shared_ptr<database::ITagParser> tag_parser)
+FatfsAudioInput::FatfsAudioInput(database::ITagParser& tag_parser)
     : IAudioSource(),
       tag_parser_(tag_parser),
       new_stream_mutex_(),
@@ -119,7 +118,7 @@ auto FatfsAudioInput::OpenFile(const std::string& path) -> bool {
   ESP_LOGI(kTag, "opening file %s", path.c_str());
 
   database::TrackTags tags;
-  if (!tag_parser_->ReadAndParseTags(path, &tags)) {
+  if (!tag_parser_.ReadAndParseTags(path, &tags)) {
     ESP_LOGE(kTag, "failed to read tags");
     return false;
   }
diff --git a/src/audio/i2s_audio_output.cpp b/src/audio/i2s_audio_output.cpp
index 359cd4c6..927f6541 100644
--- a/src/audio/i2s_audio_output.cpp
+++ b/src/audio/i2s_audio_output.cpp
@@ -41,11 +41,11 @@ static constexpr uint16_t kDefaultVolume = 0x100;
 
 static constexpr size_t kDrainBufferSize = 8 * 1024;
 
-I2SAudioOutput::I2SAudioOutput(drivers::IGpios* expander,
-                               std::weak_ptr<drivers::I2SDac> dac)
+I2SAudioOutput::I2SAudioOutput(drivers::IGpios& expander,
+                               std::unique_ptr<drivers::I2SDac> dac)
     : IAudioOutput(kDrainBufferSize, MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT),
       expander_(expander),
-      dac_(dac.lock()),
+      dac_(std::move(dac)),
       current_config_(),
       left_difference_(0),
       current_volume_(kDefaultVolume),
diff --git a/src/audio/include/audio_fsm.hpp b/src/audio/include/audio_fsm.hpp
index cfa65551..1376feae 100644
--- a/src/audio/include/audio_fsm.hpp
+++ b/src/audio/include/audio_fsm.hpp
@@ -11,6 +11,7 @@
 #include <vector>
 
 #include "audio_sink.hpp"
+#include "service_locator.hpp"
 #include "tinyfsm.hpp"
 
 #include "audio_decoder.hpp"
@@ -32,12 +33,6 @@ namespace audio {
 
 class AudioState : public tinyfsm::Fsm<AudioState> {
  public:
-  static auto Init(drivers::IGpios* gpio_expander,
-                   std::weak_ptr<database::Database>,
-                   std::shared_ptr<database::ITagParser>,
-                   drivers::Bluetooth* bluetooth,
-                   TrackQueue* queue) -> bool;
-
   virtual ~AudioState() {}
 
   virtual void entry() {}
@@ -46,8 +41,6 @@ class AudioState : public tinyfsm::Fsm<AudioState> {
   /* Fallback event handler. Does nothing. */
   void react(const tinyfsm::Event& ev) {}
 
-  void react(const system_fsm::StorageMounted&);
-
   void react(const system_fsm::KeyUpChanged&);
   void react(const system_fsm::KeyDownChanged&);
   void react(const system_fsm::HasPhonesChanged&);
@@ -65,16 +58,13 @@ class AudioState : public tinyfsm::Fsm<AudioState> {
   virtual void react(const internal::AudioPipelineIdle&) {}
 
  protected:
-  static drivers::IGpios* sIGpios;
-  static std::shared_ptr<drivers::I2SDac> sDac;
-  static std::weak_ptr<database::Database> sDatabase;
+  static std::shared_ptr<system_fsm::ServiceLocator> sServices;
 
   static std::shared_ptr<FatfsAudioInput> sFileSource;
   static std::unique_ptr<Decoder> sDecoder;
   static std::shared_ptr<SampleConverter> sSampleConverter;
   static std::shared_ptr<IAudioOutput> sOutput;
 
-  static TrackQueue* sTrackQueue;
   static std::optional<database::TrackId> sCurrentTrack;
 };
 
diff --git a/src/audio/include/fatfs_audio_input.hpp b/src/audio/include/fatfs_audio_input.hpp
index da44d2ec..b67d29dc 100644
--- a/src/audio/include/fatfs_audio_input.hpp
+++ b/src/audio/include/fatfs_audio_input.hpp
@@ -30,7 +30,7 @@ namespace audio {
  */
 class FatfsAudioInput : public IAudioSource {
  public:
-  explicit FatfsAudioInput(std::shared_ptr<database::ITagParser> tag_parser);
+  explicit FatfsAudioInput(database::ITagParser& tag_parser);
   ~FatfsAudioInput();
 
   /*
@@ -53,7 +53,7 @@ class FatfsAudioInput : public IAudioSource {
   auto ContainerToStreamType(database::Container)
       -> std::optional<codecs::StreamType>;
 
-  std::shared_ptr<database::ITagParser> tag_parser_;
+  database::ITagParser& tag_parser_;
 
   std::mutex new_stream_mutex_;
   std::shared_ptr<codecs::IStream> new_stream_;
diff --git a/src/audio/include/i2s_audio_output.hpp b/src/audio/include/i2s_audio_output.hpp
index 0068916e..fa09deef 100644
--- a/src/audio/include/i2s_audio_output.hpp
+++ b/src/audio/include/i2s_audio_output.hpp
@@ -19,7 +19,8 @@ namespace audio {
 
 class I2SAudioOutput : public IAudioOutput {
  public:
-  I2SAudioOutput(drivers::IGpios* expander, std::weak_ptr<drivers::I2SDac> dac);
+  I2SAudioOutput(drivers::IGpios& expander,
+                 std::unique_ptr<drivers::I2SDac> dac);
   ~I2SAudioOutput();
 
   auto SetInUse(bool) -> void override;
@@ -37,8 +38,8 @@ class I2SAudioOutput : public IAudioOutput {
   I2SAudioOutput& operator=(const I2SAudioOutput&) = delete;
 
  private:
-  drivers::IGpios* expander_;
-  std::shared_ptr<drivers::I2SDac> dac_;
+  drivers::IGpios& expander_;
+  std::unique_ptr<drivers::I2SDac> dac_;
 
   std::optional<Format> current_config_;
   int_fast8_t left_difference_;