WIP: Add last_position field to track data and start on implementation

src/tangara/audio/audio_fsm.cpp

@@ -80,6 +80,10 @@ auto AudioState::emitPlaybackUpdate(bool paused) -> void {
                current.first->start_offset.value_or(0);
   }
 
+  if (position) {
+    // Update position if the duration has been long enough
+  }
+
   PlaybackUpdate event{
       .current_track = current.first,
       .track_position = position,
@@ -374,6 +378,27 @@ void AudioState::react(const OutputModeChanged& ev) {
   }
 }
 
+auto AudioState::updateSavedPosition(std::string uri, uint32_t position)
+    -> void {
+  sServices->bg_worker().Dispatch<void>([=]() {
+    auto db = sServices->database().lock();
+    if (!db) {
+      return;
+    }
+    auto id = db->getTrackID(uri);
+    if (!id) {
+      return;
+    }
+    auto track = db->getTrack(*id);
+    if (!track) {
+      return;
+    }
+    database::TrackData data = track->data();
+    data.last_position = position;
+    db->setTrackData(*id, data);
+  });
+}
+
 auto AudioState::commitVolume() -> void {
   auto mode = sServices->nvs().OutputMode();
   auto vol = sOutput->GetVolume();

src/tangara/audio/audio_fsm.hpp

@@ -73,6 +73,8 @@ class AudioState : public tinyfsm::Fsm<AudioState> {
   auto emitPlaybackUpdate(bool paused) -> void;
   auto commitVolume() -> void;
 
+  auto updateSavedPosition(std::string uri, uint32_t position) -> void;
+
   static std::shared_ptr<system_fsm::ServiceLocator> sServices;
 
   static std::shared_ptr<FatfsStreamFactory> sStreamFactory;

src/tangara/database/database.cpp

@@ -44,6 +44,7 @@
 #include "memory_resource.hpp"
 #include "result.hpp"
 #include "tasks.hpp"
+#include "database.hpp"
 
 namespace database {
 
@@ -269,6 +270,24 @@ auto Database::getTrack(TrackId id) -> std::shared_ptr<Track> {
   return std::make_shared<Track>(data, tags);
 }
 
+auto Database::getTrackID(std::string path) -> std::optional<TrackId> {
+  std::string raw_data;
+  if (!db_->Get(leveldb::ReadOptions(), EncodePathKey(path), &raw_data).ok()) {
+    return {};
+  }
+  return BytesToTrackId(raw_data);
+}
+
+auto Database::setTrackData(TrackId id, const TrackData& data) -> void {
+  std::string key = EncodeDataKey(id);
+  std::string raw_val = EncodeDataValue(data);
+  
+  auto res = db_->Put(leveldb::WriteOptions(), key, raw_val);
+  if (!res.ok()) {
+    ESP_LOGI(kTag, "Updating track data failed for track ID: %lu", id);
+  }
+}
+
 auto Database::getIndexes() -> std::vector<IndexInfo> {
   // TODO(jacqueline): This probably needs to be async? When we have runtime
   // configurable indexes, they will need to come from somewhere.

src/tangara/database/database.hpp

@@ -37,7 +37,7 @@
 
 namespace database {
 
-const uint8_t kCurrentDbVersion = 7;
+const uint8_t kCurrentDbVersion = 8;
 
 struct SearchKey;
 class Record;
@@ -78,6 +78,9 @@ class Database {
 
   auto getTrackPath(TrackId id) -> std::optional<std::string>;
   auto getTrack(TrackId id) -> std::shared_ptr<Track>;
+  auto getTrackID(std::string path) -> std::optional<TrackId>;
+
+  auto setTrackData(TrackId id, const TrackData& data) -> void;
 
   auto getIndexes() -> std::vector<IndexInfo>;
   auto updateIndexes() -> void;

src/tangara/database/records.cpp

@@ -93,6 +93,7 @@ auto EncodeDataValue(const TrackData& track) -> std::string {
       cppbor::Uint{track.modified_at.first},
       cppbor::Uint{track.modified_at.second},
       tag_hashes,
+      cppbor::Uint{track.last_position},
   };
   return val.toString();
 }
@@ -127,6 +128,9 @@ auto ParseDataValue(const leveldb::Slice& slice) -> std::shared_ptr<TrackData> {
     auto tag = static_cast<Tag>(entry.first->asUint()->unsignedValue());
     res->individual_tag_hashes[tag] = entry.second->asUint()->unsignedValue();
   }
+
+  res->last_position = vals->get(7)->asUint()->unsignedValue();
+
   return res;
 }
 

src/tangara/database/track.hpp

@@ -159,7 +159,8 @@ struct TrackData {
         tags_hash(0),
         individual_tag_hashes(&memory::kSpiRamResource),
         is_tombstoned(false),
-        modified_at() {}
+        modified_at(),
+        last_position(0) {}
 
   TrackId id;
   std::pmr::string filepath;
@@ -167,9 +168,10 @@ struct TrackData {
   std::pmr::unordered_map<Tag, uint64_t> individual_tag_hashes;
   bool is_tombstoned;
   std::pair<uint16_t, uint16_t> modified_at;
+  uint32_t last_position;
 
-  TrackData(TrackData&& other) = delete;
-  TrackData& operator=(TrackData& other) = delete;
+  TrackData(const TrackData& other) = default;
+  TrackData& operator=(TrackData& other) = default;
 
   bool operator==(const TrackData&) const = default;
 };