feat(sdk): Migrate from SS to SSS.

This patch migrates the code from SS  to SSS. It means that `sort` and
`bump_event_types` in lists, or room unsubscriptions, in the requests
are removed, or `timestamp` migrates to `bump_stamp` etc.

Author: Hywan

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

@@ -3,12 +3,10 @@ use std::{fmt::Debug, mem::MaybeUninit, ptr::addr_of_mut, sync::Arc, time::Durat
 use eyeball_im::VectorDiff;
 use futures_util::{pin_mut, StreamExt, TryFutureExt};
 use matrix_sdk::ruma::{
-    api::client::sync::sync_events::{
-        v4::RoomSubscription as RumaRoomSubscription,
-        UnreadNotificationsCount as RumaUnreadNotificationsCount,
-    },
+    api::client::sync::sync_events::UnreadNotificationsCount as RumaUnreadNotificationsCount,
     assign, RoomId,
 };
+use matrix_sdk::sliding_sync::http;
 use matrix_sdk_ui::{
     room_list_service::filters::{
         new_filter_all, new_filter_any, new_filter_category, new_filter_favourite,
@@ -653,10 +651,6 @@ impl RoomListItem {
         self.inner.subscribe(settings.map(Into::into));
     }
 
-    fn unsubscribe(&self) {
-        self.inner.unsubscribe();
-    }
-
     async fn latest_event(&self) -> Option<Arc<EventTimelineItem>> {
         self.inner.latest_event().await.map(EventTimelineItem).map(Arc::new)
     }
@@ -675,9 +669,9 @@ pub struct RoomSubscription {
     pub include_heroes: Option<bool>,
 }
 
-impl From<RoomSubscription> for RumaRoomSubscription {
+impl From<RoomSubscription> for http::RequestRoomSubscription {
     fn from(val: RoomSubscription) -> Self {
-        assign!(RumaRoomSubscription::default(), {
+        assign!(http::RequestRoomSubscription::default(), {
             required_state: val.required_state.map(|r|
                 r.into_iter().map(|s| (s.key.into(), s.value)).collect()
             ).unwrap_or_default(),

crates/matrix-sdk-base/Cargo.toml

@@ -26,6 +26,7 @@ experimental-sliding-sync = [
     "ruma/unstable-msc3575",
     "ruma/unstable-simplified-msc3575",
 ]
+experimental-simplified-sliding-sync = ["experimental-sliding-sync"]
 uniffi = ["dep:uniffi", "matrix-sdk-crypto?/uniffi"]
 
 # helpers for testing features build upon this

crates/matrix-sdk-base/src/rooms/normal.rs

@@ -24,6 +24,8 @@ use bitflags::bitflags;
 use eyeball::{SharedObservable, Subscriber};
 #[cfg(all(feature = "e2e-encryption", feature = "experimental-sliding-sync"))]
 use matrix_sdk_common::ring_buffer::RingBuffer;
+#[cfg(feature = "experimental-sliding-sync")]
+use ruma::events::AnySyncTimelineEvent;
 use ruma::{
     api::client::sync::sync_events::v3::RoomSummary as RumaSummary,
     events::{
@@ -49,8 +51,6 @@ use ruma::{
     EventId, MxcUri, OwnedEventId, OwnedMxcUri, OwnedRoomAliasId, OwnedRoomId, OwnedUserId,
     RoomAliasId, RoomId, RoomVersionId, UserId,
 };
-#[cfg(feature = "experimental-sliding-sync")]
-use ruma::{events::AnySyncTimelineEvent, MilliSecondsSinceUnixEpoch};
 use serde::{Deserialize, Serialize};
 use tokio::sync::broadcast;
 use tracing::{debug, field::debug, info, instrument, warn};
@@ -91,8 +91,8 @@ bitflags! {
     /// The reason why a [`RoomInfoNotableUpdate`] is emitted.
     #[derive(Clone, Copy, Debug, Eq, PartialEq)]
     pub struct RoomInfoNotableUpdateReasons: u8 {
-        /// The recency timestamp of the `Room` has changed.
-        const RECENCY_TIMESTAMP = 0b0000_0001;
+        /// The recency stamp of the `Room` has changed.
+        const RECENCY_STAMP = 0b0000_0001;
 
         /// The latest event of the `Room` has changed.
         const LATEST_EVENT = 0b0000_0010;
@@ -923,12 +923,12 @@ impl Room {
         self.inner.read().base_info.is_marked_unread
     }
 
-    /// Returns the recency timestamp of the room.
+    /// Returns the recency stamp of the room.
     ///
-    /// Please read `RoomInfo::recency_timestamp` to learn more.
+    /// Please read `RoomInfo::recency_stamp` to learn more.
     #[cfg(feature = "experimental-sliding-sync")]
-    pub fn recency_timestamp(&self) -> Option<MilliSecondsSinceUnixEpoch> {
-        self.inner.read().recency_timestamp
+    pub fn recency_stamp(&self) -> Option<u64> {
+        self.inner.read().recency_stamp
     }
 }
 
@@ -989,15 +989,15 @@ pub struct RoomInfo {
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub(crate) cached_display_name: Option<DisplayName>,
 
-    /// The recency timestamp of this room.
+    /// The recency stamp of this room.
     ///
     /// It's not to be confused with `origin_server_ts` of the latest event.
     /// Sliding Sync might "ignore” some events when computing the recency
-    /// timestamp of the room. Thus, using this `recency_timestamp` value is
+    /// stamp of the room. Thus, using this `recency_stamp` value is
     /// more accurate than relying on the latest event.
     #[cfg(feature = "experimental-sliding-sync")]
     #[serde(default)]
-    pub(crate) recency_timestamp: Option<MilliSecondsSinceUnixEpoch>,
+    pub(crate) recency_stamp: Option<u64>,
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
@@ -1036,7 +1036,7 @@ impl RoomInfo {
             warned_about_unknown_room_version: Arc::new(false.into()),
             cached_display_name: None,
             #[cfg(feature = "experimental-sliding-sync")]
-            recency_timestamp: None,
+            recency_stamp: None,
         }
     }
 
@@ -1442,12 +1442,12 @@ impl RoomInfo {
         self.latest_event.as_deref()
     }
 
-    /// Updates the recency timestamp of this room.
+    /// Updates the recency stamp of this room.
     ///
-    /// Please read [`Self::recency_timestamp`] to learn more.
+    /// Please read [`Self::recency_stamp`] to learn more.
     #[cfg(feature = "experimental-sliding-sync")]
-    pub(crate) fn update_recency_timestamp(&mut self, timestamp: MilliSecondsSinceUnixEpoch) {
-        self.recency_timestamp = Some(timestamp);
+    pub(crate) fn update_recency_stamp(&mut self, stamp: u64) {
+        self.recency_stamp = Some(stamp);
     }
 }
 
@@ -1663,7 +1663,7 @@ mod tests {
             read_receipts: Default::default(),
             warned_about_unknown_room_version: Arc::new(false.into()),
             cached_display_name: None,
-            recency_timestamp: Some(MilliSecondsSinceUnixEpoch(42u32.into())),
+            recency_stamp: Some(42),
         };
 
         let info_json = json!({
@@ -1716,7 +1716,7 @@ mod tests {
                 "latest_active": null,
                 "pending": []
             },
-            "recency_timestamp": 42,
+            "recency_stamp": 42,
         });
 
         assert_eq!(serde_json::to_value(info).unwrap(), info_json);

crates/matrix-sdk-base/src/sliding_sync/http.rs

@@ -63,34 +63,30 @@ where
 }
 
 mod ss {
-    use super::{sss, From};
     use ruma::{api::client::sync::sync_events::v4, events::TimelineEventType};
-
+    // Response types.
+    pub use v4::{
+        Extensions as ResponseExtensions, Response, SlidingSyncRoom as ResponseRoom,
+        SlidingSyncRoomHero as ResponseRoomHero, SyncList as ResponseList,
+    };
     // Request types.
     pub use v4::{
         ExtensionsConfig as RequestExtensions, Request, RoomDetailsConfig as RequestRoomDetails,
         RoomSubscription as RequestRoomSubscription, SyncRequestList as RequestList,
         SyncRequestListFilters as RequestListFilters,
     };
 
-    // Response types.
-    pub use v4::{
-        Extensions as ResponseExtensions, Response, SlidingSyncRoom as ResponseRoom,
-        SlidingSyncRoomHero as ResponseRoomHero, SyncList as ResponseList,
-    };
+    use super::{sss, From};
 
     pub mod extensions {
         // Request types.
-        pub use super::v4::{
-            AccountDataConfig as RequestAccountData, E2EEConfig as RequestE2EE,
-            ReceiptsConfig as RequestReceipts, RoomReceiptConfig as RequestReceiptsRoom,
-            ToDeviceConfig as RequestToDevice, TypingConfig as RequestTyping,
-        };
-
         // Response types.
         pub use super::v4::{
-            AccountData as ResponseAccountData, Receipts as ResponseReceipts,
-            ToDevice as ResponseToDevice, Typing as ResponseTyping, E2EE as ResponseE2EE,
+            AccountData as ResponseAccountData, AccountDataConfig as RequestAccountData,
+            E2EEConfig as RequestE2EE, Receipts as ResponseReceipts,
+            ReceiptsConfig as RequestReceipts, RoomReceiptConfig as RequestReceiptsRoom,
+            ToDevice as ResponseToDevice, ToDeviceConfig as RequestToDevice,
+            Typing as ResponseTyping, TypingConfig as RequestTyping, E2EE as ResponseE2EE,
         };
     }
 
@@ -118,7 +114,9 @@ mod ss {
             s.room_details = From::from(value.room_details);
             s.include_heroes = value.include_heroes;
             s.filters = From::from(value.filters);
-            s.sort = vec!["by_recency".to_string(), "by_name".to_string()];
+
+            // Defaults from Simplified MSC3575.
+            s.sort = vec!["by_recency".to_owned(), "by_name".to_owned()];
             s.bump_event_types = vec![
                 TimelineEventType::RoomMessage,
                 TimelineEventType::RoomEncrypted,
@@ -248,9 +246,10 @@ mod ss {
 }
 
 mod sss {
-    use super::{ss, From};
     pub use ruma::api::client::sync::sync_events::v5::*;
 
+    use super::{ss, From};
+
     impl From<ss::Response> for Response {
         fn from(value: ss::Response) -> Self {
             let mut s = Self::new(value.pos);