desktop-app: Observe track search state

uklotzde · uklotzde · commit abfbd8cf2bf3 · 2024-02-10T20:05:03.000+01:00
diff --git a/crates/desktop-app/src/track/repo_search/mod.rs b/crates/desktop-app/src/track/repo_search/mod.rs
@@ -28,6 +28,12 @@ pub struct FetchedEntity {
     pub entity: Entity,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct FetchedEntitiesFingerprint {
+    pub len: usize,
+    pub last_offset_hash: u64,
+}
+
 #[must_use]
 pub fn last_offset_hash_of_fetched_entities<'a>(
     fetched_entities: impl Into<Option<&'a [FetchedEntity]>>,
@@ -40,6 +46,32 @@ pub fn last_offset_hash_of_fetched_entities<'a>(
         })
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub enum FetchStateTag {
+    #[default]
+    Initial,
+    Ready,
+    Pending,
+    Failed,
+}
+
+impl FetchStateTag {
+    /// Check whether the state is stable.
+    #[must_use]
+    pub const fn is_idle(&self) -> bool {
+        match self {
+            Self::Initial | Self::Ready | Self::Failed => true,
+            Self::Pending => false,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+pub struct FetchStateLite {
+    pub tag: FetchStateTag,
+    pub fetched_entities_fingerprint: Option<FetchedEntitiesFingerprint>,
+}
+
 #[derive(Debug, Default)]
 enum FetchState {
     #[default]
@@ -53,19 +85,42 @@ enum FetchState {
     },
     Failed {
         fetched_entities_before: Option<Vec<FetchedEntity>>,
-        err: anyhow::Error,
+        error: anyhow::Error,
     },
 }
 
 impl FetchState {
     #[must_use]
-    const fn is_idle(&self) -> bool {
+    const fn state_tag(&self) -> FetchStateTag {
         match self {
-            Self::Initial | Self::Ready { .. } | Self::Failed { .. } => true,
-            Self::Pending { .. } => false,
+            Self::Initial => FetchStateTag::Initial,
+            Self::Ready { .. } => FetchStateTag::Ready,
+            Self::Failed { .. } => FetchStateTag::Failed,
+            Self::Pending { .. } => FetchStateTag::Pending,
+        }
+    }
+
+    #[must_use]
+    fn clone_lite(&self) -> FetchStateLite {
+        let tag = self.state_tag();
+        let fetched_entities_fingerprint = self.fetched_entities_fingerprint();
+        FetchStateLite {
+            tag,
+            fetched_entities_fingerprint,
         }
     }
 
+    #[must_use]
+    fn equals_lite(&self, other: &FetchStateLite) -> bool {
+        self.clone_lite() == *other
+    }
+
+    /// Check whether the state is stable.
+    #[must_use]
+    const fn is_idle(&self) -> bool {
+        self.state_tag().is_idle()
+    }
+
     #[must_use]
     fn fetched_entities(&self) -> Option<&[FetchedEntity]> {
         match self {
@@ -84,6 +139,17 @@ impl FetchState {
         }
     }
 
+    #[must_use]
+    fn fetched_entities_fingerprint(&self) -> Option<FetchedEntitiesFingerprint> {
+        let fetched_entities = self.fetched_entities()?;
+        let len = fetched_entities.len();
+        let last_offset_hash = last_offset_hash_of_fetched_entities(fetched_entities);
+        Some(FetchedEntitiesFingerprint {
+            len,
+            last_offset_hash,
+        })
+    }
+
     #[must_use]
     const fn should_prefetch(&self) -> bool {
         matches!(self, Self::Initial)
@@ -92,8 +158,8 @@ impl FetchState {
     #[must_use]
     const fn can_fetch_more(&self) -> Option<bool> {
         match self {
-            Self::Initial => Some(true),                                 // always
-            Self::Pending { .. } | Self::Failed { .. } => None,          // undefined
+            Self::Initial => Some(true), // always, i.e. try at least once
+            Self::Pending { .. } | Self::Failed { .. } => None, // undefined
             Self::Ready { can_fetch_more, .. } => Some(*can_fetch_more), // maybe
         }
     }
@@ -102,7 +168,7 @@ impl FetchState {
     const fn last_error(&self) -> Option<&anyhow::Error> {
         match self {
             Self::Initial | Self::Pending { .. } | Self::Ready { .. } => None,
-            Self::Failed { err, .. } => Some(err),
+            Self::Failed { error, .. } => Some(error),
         }
     }
 
@@ -189,8 +255,8 @@ impl FetchState {
     }
 
     #[allow(clippy::needless_pass_by_value)]
-    fn fetch_more_failed(&mut self, err: anyhow::Error) -> bool {
-        log::warn!("Fetching failed: {err}");
+    fn fetch_more_failed(&mut self, error: anyhow::Error) -> bool {
+        log::warn!("Fetching failed: {error}");
         let Self::Pending {
             fetched_entities_before,
         } = self
@@ -202,12 +268,19 @@ impl FetchState {
         let fetched_entities_before = std::mem::take(fetched_entities_before);
         *self = Self::Failed {
             fetched_entities_before,
-            err,
+            error,
         };
         true
     }
 }
 
+#[derive(Debug, Clone, Default, PartialEq)]
+pub struct StateLite {
+    pub default_params: Params,
+    pub context: Context,
+    pub fetch: FetchStateLite,
+}
+
 #[derive(Debug)]
 pub struct State {
     default_params: Params,
@@ -271,6 +344,45 @@ impl State {
         self.fetch.fetched_entities()
     }
 
+    #[must_use]
+    pub fn fetched_entities_fingerprint(&self) -> Option<FetchedEntitiesFingerprint> {
+        self.fetch.fetched_entities_fingerprint()
+    }
+
+    #[must_use]
+    pub fn clone_lite(&self) -> StateLite {
+        let Self {
+            default_params,
+            context,
+            fetch,
+        } = self;
+        let default_params = default_params.clone();
+        let context = context.clone();
+        let fetch = fetch.clone_lite();
+        StateLite {
+            default_params,
+            context,
+            fetch,
+        }
+    }
+
+    #[must_use]
+    pub fn equals_lite(&self, other: &StateLite) -> bool {
+        let Self {
+            default_params,
+            context,
+            fetch,
+        } = self;
+        let StateLite {
+            default_params: other_default_params,
+            context: other_context,
+            fetch: other_fetch,
+        } = other;
+        default_params == other_default_params
+            && context == other_context
+            && fetch.equals_lite(other_fetch)
+    }
+
     pub fn reset(&mut self) -> bool {
         // Cloning the default params once for pre-creating the target state
         // is required to avoid redundant code for determining in advance if
diff --git a/demo-app/src/library/collection.rs b/demo-app/src/library/collection.rs
@@ -28,11 +28,11 @@ where
 {
     // The first event is always emitted immediately.
     loop {
+        drop(subscriber.read_ack());
         let Some(event_emitter) = event_emitter.upgrade() else {
             log::info!("Stop watching collection state after event emitter has been dropped");
             break;
         };
-        drop(subscriber.read_ack());
         event_emitter.emit_notification(LibraryNotification::CollectionStateChanged);
         if subscriber.changed().await.is_err() {
             log::info!("Stop watching collection state after publisher has been dropped");
diff --git a/demo-app/src/library/mod.rs b/demo-app/src/library/mod.rs
@@ -35,7 +35,7 @@ const TRACK_REPO_SEARCH_PREFETCH_LIMIT: NonZeroUsize =
 #[derive(Debug)]
 #[allow(clippy::enum_variant_names)] // common `...Changed` suffix
 pub enum LibraryNotification {
-    SettingsStateChanged(settings::State),
+    SettingsStateChanged,
     CollectionStateChanged,
     TrackSearchStateChanged,
 }
diff --git a/demo-app/src/library/settings.rs b/demo-app/src/library/settings.rs
@@ -18,13 +18,12 @@ where
 {
     // The first event is always emitted immediately.
     loop {
+        drop(subscriber.read_ack());
         let Some(event_emitter) = event_emitter.upgrade() else {
             log::info!("Stop watching settings state after event emitter has been dropped");
             break;
         };
-        // The lock is released immediately after cloning the state.
-        let state = subscriber.read_ack().clone();
-        event_emitter.emit_notification(LibraryNotification::SettingsStateChanged(state.clone()));
+        event_emitter.emit_notification(LibraryNotification::SettingsStateChanged);
         if subscriber.changed().await.is_err() {
             log::info!("Stop watching settings state after publisher has been dropped");
             break;
diff --git a/demo-app/src/library/track_search.rs b/demo-app/src/library/track_search.rs
@@ -32,6 +32,7 @@ where
 {
     // The first event is always emitted immediately.
     loop {
+        drop(subscriber.read_ack());
         let Some(event_emitter) = event_emitter.upgrade() else {
             log::info!("Stop watching track search state after event emitter has been dropped");
             break;
diff --git a/demo-app/src/main.rs b/demo-app/src/main.rs
@@ -328,6 +328,7 @@ struct AppModel {
     music_dir: Option<DirPath<'static>>,
     collection_state: CollectionState,
     track_search_input: String,
+    track_search_state: aoide::desktop_app::track::repo_search::StateLite,
 }
 
 impl AppModel {
@@ -337,6 +338,7 @@ impl AppModel {
             music_dir: Default::default(),
             collection_state: Default::default(),
             track_search_input: Default::default(),
+            track_search_state: Default::default(),
         }
     }
 }
@@ -390,41 +392,60 @@ impl Model for AppModel {
             },
             AppEvent::Notification(notification) => match notification {
                 AppNotification::Library(library) => match library {
-                    LibraryNotification::SettingsStateChanged(state) => {
-                        if state.music_dir == self.music_dir {
-                            log::info!(
-                                "Music directory unchanged: {music_dir:?}",
-                                music_dir = self.music_dir
-                            );
-                            return;
-                        }
-                        let new_music_dir = state.music_dir.clone();
-                        log::info!(
+                    LibraryNotification::SettingsStateChanged => {
+                        let new_music_dir = {
+                            let settings_state = self.app.library.state().settings().read_observable();
+                            if settings_state.music_dir == self.music_dir {
+                                log::debug!(
+                                    "Music directory unchanged: {music_dir:?}",
+                                    music_dir = self.music_dir,
+                                );
+                                return;
+                            }
+                            settings_state.music_dir.clone()
+                        };
+                        log::debug!(
                             "Music directory changed: {old_music_dir:?} -> {new_music_dir:?}",
                             old_music_dir = self.music_dir,
                         );
                         self.music_dir = new_music_dir;
                     }
                     LibraryNotification::CollectionStateChanged => {
-                        let new_collection_state = {
-                            let new_collection_state = self.app.library.state().collection().read_observable();
-                            if *new_collection_state == self.collection_state {
-                                log::info!(
-                                    "Collection state unchanged: {old_collection_state:?}",
-                                    old_collection_state = self.collection_state,
+                        let new_state = {
+                            let new_state = self.app.library.state().collection().read_observable();
+                            if *new_state == self.collection_state {
+                                log::debug!(
+                                    "Collection state unchanged: {old_state:?}",
+                                    old_state = self.collection_state,
                                 );
                                 return;
                             }
-                            new_collection_state.clone()
+                            new_state.clone()
                         };
-                        log::info!(
-                            "Collection state changed: {old_collection_state:?} -> {new_collection_state:?}",
-                            old_collection_state = self.collection_state,
+                        log::debug!(
+                            "Collection state changed: {old_state:?} -> {new_state:?}",
+                            old_state = self.collection_state,
                         );
-                        self.collection_state = new_collection_state;
+                        self.collection_state = new_state;
                     }
                     LibraryNotification::TrackSearchStateChanged => {
-                        log::warn!("TODO: Track search state changed");
+                        let new_state = {
+                            let new_state = self.app.library.state().track_search().read_observable();
+                            if new_state.equals_lite(&self.track_search_state) {
+                                log::debug!(
+                                    "Track search state unchanged: {old_state:?}",
+                                    old_state = self.track_search_state,
+                                );
+                                return;
+                            }
+                            new_state.clone_lite()
+                        };
+                        log::debug!(
+                            "Track search state changed: {old_state:?} -> {new_state:?}",
+                            old_state = self.track_search_state,
+                        );
+                        self.track_search_state = new_state;
+                        log::warn!("TODO: Show fetched entities");
                     }
                 },
             },

Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ const TRACK_REPO_SEARCH_PREFETCH_LIMIT: NonZeroUsize =`
`35`	`35`	`#[derive(Debug)]`
`36`	`36`	#[allow(clippy::enum_variant_names)] // common `...Changed` suffix
`37`	`37`	`pub enum LibraryNotification {`
`38`		`- SettingsStateChanged(settings::State),`
	`38`	`+ SettingsStateChanged,`
`39`	`39`	`CollectionStateChanged,`
`40`	`40`	`TrackSearchStateChanged,`
`41`	`41`	`}`
Original file line number	Diff line number	Diff line change
`@@ -32,6 +32,7 @@ where`
`32`	`32`	`{`
`33`	`33`	`// The first event is always emitted immediately.`
`34`	`34`	`loop {`
	`35`	`+ drop(subscriber.read_ack());`
`35`	`36`	`let Some(event_emitter) = event_emitter.upgrade() else {`
`36`	`37`	`log::info!("Stop watching track search state after event emitter has been dropped");`
`37`	`38`	`break;`