feat(sdk): Rename SlidingSyncState to SlidingSyncListLoadingState.

This patch renames `SlidingSyncState` to `SlidingSyncListLoadingState`
because:

1. It's about a list information,
2. It's about the loading state, not a generic state.

bindings/matrix-sdk-ffi/src/api.udl

@@ -1,6 +1,6 @@
 namespace matrix_sdk_ffi {};
 
-enum SlidingSyncState {
+enum SlidingSyncListLoadingState {
     /// Sliding Sync has not started to load anything yet.
     "NotLoaded",
     /// Sliding Sync has been preloaded, i.e. restored from a cache for example.

bindings/matrix-sdk-ffi/src/lib.rs

@@ -40,7 +40,7 @@ mod tracing;
 use async_compat::TOKIO1 as RUNTIME;
 use matrix_sdk::{
     ruma::events::room::{message::RoomMessageEventContent, MediaSource},
-    SlidingSyncState,
+    SlidingSyncListLoadingState,
 };
 
 use self::{

bindings/matrix-sdk-ffi/src/sliding_sync.rs

@@ -13,7 +13,7 @@ use matrix_sdk::{
     },
     sliding_sync::SlidingSyncSelectiveModeBuilder as MatrixSlidingSyncSelectiveModeBuilder,
     LoopCtrl, RoomListEntry as MatrixRoomEntry, SlidingSyncBuilder as MatrixSlidingSyncBuilder,
-    SlidingSyncMode, SlidingSyncState,
+    SlidingSyncListLoadingState, SlidingSyncMode,
 };
 use matrix_sdk_ui::timeline::SlidingSyncRoomExt;
 use tracing::{error, warn};
@@ -370,7 +370,7 @@ pub trait SlidingSyncListRoomsCountObserver: Sync + Send {
 
 #[uniffi::export(callback_interface)]
 pub trait SlidingSyncListStateObserver: Sync + Send {
-    fn did_receive_update(&self, new_state: SlidingSyncState);
+    fn did_receive_update(&self, new_state: SlidingSyncListLoadingState);
 }
 
 #[derive(Clone, uniffi::Object)]

crates/matrix-sdk/src/lib.rs

@@ -61,7 +61,7 @@ pub use ruma::{IdParseError, OwnedServerName, ServerName};
 #[cfg(feature = "experimental-sliding-sync")]
 pub use sliding_sync::{
     RoomListEntry, SlidingSync, SlidingSyncBuilder, SlidingSyncList, SlidingSyncListBuilder,
-    SlidingSyncMode, SlidingSyncRoom, SlidingSyncState, UpdateSummary,
+    SlidingSyncListLoadingState, SlidingSyncMode, SlidingSyncRoom, UpdateSummary,
 };
 
 #[cfg(any(test, feature = "testing"))]

crates/matrix-sdk/src/sliding_sync/README.md

@@ -365,8 +365,8 @@ caching has been enabled before. In this case, during
 `.build()`[`SlidingSyncBuilder::build`] sliding sync will attempt to load their
 latest cached version from storage, as well as some overall information of
 Sliding Sync. If that succeeded the lists `state` has been set to
-[`Preloaded`][SlidingSyncState::Preloaded]. Only room data of rooms present in
-one of the lists is loaded from storage.
+[`Preloaded`][SlidingSyncListLoadingState::Preloaded]. Only room data of rooms
+present in one of the lists is loaded from storage.
 
 Any extension data will not be loaded from the cache, if added after Sliding
 Sync has been built: some extension data (like the to-device-message position)

crates/matrix-sdk/src/sliding_sync/list/builder.rs

@@ -19,8 +19,8 @@ use tokio::sync::broadcast::Sender;
 
 use super::{
     super::SlidingSyncInternalMessage, Bound, SlidingSyncList, SlidingSyncListCachePolicy,
-    SlidingSyncListInner, SlidingSyncListRequestGenerator, SlidingSyncListStickyParameters,
-    SlidingSyncMode, SlidingSyncState,
+    SlidingSyncListInner, SlidingSyncListLoadingState, SlidingSyncListRequestGenerator,
+    SlidingSyncListStickyParameters, SlidingSyncMode,
 };
 use crate::{
     sliding_sync::{
@@ -245,7 +245,10 @@ impl SlidingSyncListBuilder {
             self.reloaded_cached_data
         {
             // Mark state as preloaded.
-            Observable::set(&mut list.inner.state.write().unwrap(), SlidingSyncState::Preloaded);
+            Observable::set(
+                &mut list.inner.state.write().unwrap(),
+                SlidingSyncListLoadingState::Preloaded,
+            );
 
             // Reload values.
             Observable::set(

crates/matrix-sdk/src/sliding_sync/list/mod.rs

@@ -99,7 +99,7 @@ impl SlidingSyncList {
     }
 
     /// Get the current state.
-    pub fn state(&self) -> SlidingSyncState {
+    pub fn state(&self) -> SlidingSyncListLoadingState {
         self.inner.state.read().unwrap().clone()
     }
 
@@ -110,7 +110,7 @@ impl SlidingSyncList {
     ///
     /// There's no guarantee of ordering between items emitted by this stream
     /// and those emitted by other streams exposed on this structure.
-    pub fn state_stream(&self) -> impl Stream<Item = SlidingSyncState> {
+    pub fn state_stream(&self) -> impl Stream<Item = SlidingSyncListLoadingState> {
         Observable::subscribe(&self.inner.state.read().unwrap())
     }
 
@@ -278,7 +278,7 @@ pub(super) struct SlidingSyncListInner {
     name: String,
 
     /// The state this list is in.
-    state: StdRwLock<Observable<SlidingSyncState>>,
+    state: StdRwLock<Observable<SlidingSyncListLoadingState>>,
 
     /// Parameters that are sticky, and can be sent only once per session (until
     /// the connection is dropped or the server invalidates what the client
@@ -334,10 +334,11 @@ impl SlidingSyncListInner {
             let mut state = self.state.write().unwrap();
 
             let next_state = match **state {
-                SlidingSyncState::NotLoaded => SlidingSyncState::NotLoaded,
-                SlidingSyncState::Preloaded => SlidingSyncState::Preloaded,
-                SlidingSyncState::PartiallyLoaded | SlidingSyncState::FullyLoaded => {
-                    SlidingSyncState::PartiallyLoaded
+                SlidingSyncListLoadingState::NotLoaded => SlidingSyncListLoadingState::NotLoaded,
+                SlidingSyncListLoadingState::Preloaded => SlidingSyncListLoadingState::Preloaded,
+                SlidingSyncListLoadingState::PartiallyLoaded
+                | SlidingSyncListLoadingState::FullyLoaded => {
+                    SlidingSyncListLoadingState::PartiallyLoaded
                 }
             };
 
@@ -748,7 +749,7 @@ fn apply_sync_operations(
 /// If the client has been offline for a while, though, the `SlidingSyncList`
 /// might return back to `PartiallyLoaded` at any point.
 #[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub enum SlidingSyncState {
+pub enum SlidingSyncListLoadingState {
     /// Sliding Sync has not started to load anything yet.
     #[default]
     NotLoaded,
@@ -1023,7 +1024,7 @@ mod tests {
             ),*
             $(,)*
         ) => {
-            assert_eq!($list.state(), SlidingSyncState::$first_list_state, "first state");
+            assert_eq!($list.state(), SlidingSyncListLoadingState::$first_list_state, "first state");
 
             $(
                 {
@@ -1048,7 +1049,7 @@ mod tests {
                     );
                     assert_eq!(
                         $list.state(),
-                        SlidingSyncState::$list_state,
+                        SlidingSyncListLoadingState::$list_state,
                         "state",
                     );
                 }
@@ -1433,8 +1434,8 @@ mod tests {
         // Changing from `Paging` to `Selective`.
         list.set_sync_mode(SlidingSyncMode::new_selective());
 
-        assert_eq!(list.state(), SlidingSyncState::PartiallyLoaded); // we had some partial state, but we can't be sure it's fully loaded until the
-                                                                     // next request
+        assert_eq!(list.state(), SlidingSyncListLoadingState::PartiallyLoaded); // we had some partial state, but we can't be sure it's fully loaded until the
+                                                                                // next request
 
         // We need to update the ranges, of course, as they are not managed
         // automatically anymore.
@@ -1619,10 +1620,10 @@ mod tests {
 
     #[test]
     fn test_sliding_sync_state_serialization() {
-        assert_json_roundtrip!(from SlidingSyncState: SlidingSyncState::NotLoaded => json!("NotLoaded"));
-        assert_json_roundtrip!(from SlidingSyncState: SlidingSyncState::Preloaded => json!("Preloaded"));
-        assert_json_roundtrip!(from SlidingSyncState: SlidingSyncState::PartiallyLoaded => json!("PartiallyLoaded"));
-        assert_json_roundtrip!(from SlidingSyncState: SlidingSyncState::FullyLoaded => json!("FullyLoaded"));
+        assert_json_roundtrip!(from SlidingSyncListLoadingState: SlidingSyncListLoadingState::NotLoaded => json!("NotLoaded"));
+        assert_json_roundtrip!(from SlidingSyncListLoadingState: SlidingSyncListLoadingState::Preloaded => json!("Preloaded"));
+        assert_json_roundtrip!(from SlidingSyncListLoadingState: SlidingSyncListLoadingState::PartiallyLoaded => json!("PartiallyLoaded"));
+        assert_json_roundtrip!(from SlidingSyncListLoadingState: SlidingSyncListLoadingState::FullyLoaded => json!("FullyLoaded"));
     }
 
     macro_rules! entries {

crates/matrix-sdk/src/sliding_sync/list/request_generator.rs

@@ -32,7 +32,7 @@
 use std::cmp::min;
 
 use super::{Range, Ranges, SlidingSyncMode};
-use crate::{sliding_sync::Error, SlidingSyncState};
+use crate::{sliding_sync::Error, SlidingSyncListLoadingState};
 
 /// The kind of request generator.
 #[derive(Debug, PartialEq)]
@@ -198,7 +198,7 @@ impl SlidingSyncListRequestGenerator {
         &mut self,
         list_name: &str,
         maximum_number_of_rooms: u32,
-    ) -> Result<SlidingSyncState, Error> {
+    ) -> Result<SlidingSyncListLoadingState, Error> {
         match &mut self.kind {
             SlidingSyncListRequestGeneratorKind::Paging {
                 requested_end,
@@ -247,7 +247,7 @@ impl SlidingSyncListRequestGenerator {
                     self.ranges = vec![0..=range_end];
 
                     // Finally, return the new state.
-                    Ok(SlidingSyncState::PartiallyLoaded)
+                    Ok(SlidingSyncListLoadingState::PartiallyLoaded)
                 }
                 // Otherwise the current range has reached its maximum, we switched to `FullyLoaded`
                 // mode.
@@ -262,13 +262,13 @@ impl SlidingSyncListRequestGenerator {
                     self.ranges = vec![0..=range_maximum];
 
                     // Finally, let's update the list' state.
-                    Ok(SlidingSyncState::FullyLoaded)
+                    Ok(SlidingSyncListLoadingState::FullyLoaded)
                 }
             }
 
             SlidingSyncListRequestGeneratorKind::Selective => {
                 // Selective mode always loads everything.
-                Ok(SlidingSyncState::FullyLoaded)
+                Ok(SlidingSyncListLoadingState::FullyLoaded)
             }
         }
     }