matrix-rust-sdk

public

Star0

Fork 0

Watch0

58 commits 4 branches 0 tags 0 releases16.6 MiB

Commit `a0e7d274a279`

tarball

atagen <boss@atagen.co>2026-10-28 05:03 UTC

3 files changed+47-5

room-list: let the sync service set the growing batch size of the all rooms list

tuwunel resends every room in the requested range each time the list grows, so a 399 room account received most rooms four or five times at the default batch of 100, each repeat a round of event cache work. `SyncServiceBuilder::with_room_list_growing_batch_size` lets a client grow in fewer steps, and the default stays 100.

Modified file: crates/matrix-sdk-ui/src/room_list_service/mod.rs+6 additions@@ -496,6 +496,12 @@ impl RoomListService {
         self.state_machine.subscribe()
     }
 
+    /// Set how many rooms each step of the `all_rooms` list's growing sync asks
+    /// for, from the next time the list starts growing.
+    pub fn set_growing_batch_size(&self, batch_size: u32) {
+        self.state_machine.set_growing_batch_size(batch_size);
+    }
+
     async fn list_for(&self, sliding_sync_list_name: &str) -> Result<RoomList, Error> {
         RoomList::new(&self.client, &self.sliding_sync, sliding_sync_list_name, self.state()).await
     }

Modified file: crates/matrix-sdk-ui/src/room_list_service/state.rs+25 additions−5 deletions@@ -14,7 +14,13 @@
 
 //! States and actions for the `RoomList` state machine.
 
-use std::{future::ready, sync::Mutex};
+use std::{
+    future::ready,
+    sync::{
+        Mutex,
+        atomic::{AtomicU32, Ordering},
+    },
+};
 
 use eyeball::{SharedObservable, Subscriber};
 use matrix_sdk::{SlidingSync, SlidingSyncMode, sliding_sync::Range};
@@ -78,6 +84,9 @@ pub struct StateMachine {
     ///
     /// To be used in coordination with `Self::last_state_update_time`.
     state_lifespan: Duration,
+
+    /// The `batch_size` of the growing sync-mode of the `ALL_ROOMS_LIST_NAME` list.
+    growing_batch_size: AtomicU32,
 }
 
 impl StateMachine {
@@ -86,9 +95,14 @@ impl StateMachine {
             state: SharedObservable::new(State::Init),
             last_state_update_time: Mutex::new(Instant::now()),
             state_lifespan: DEFAULT_STATE_LIFESPAN,
+            growing_batch_size: AtomicU32::new(ALL_ROOMS_DEFAULT_GROWING_BATCH_SIZE),
         }
     }
 
+    pub(super) fn set_growing_batch_size(&self, batch_size: u32) {
+        self.growing_batch_size.store(batch_size, Ordering::SeqCst);
+    }
+
     /// Get the current state.
     pub(super) fn get(&self) -> State {
         self.state.get()
@@ -123,7 +137,8 @@ impl StateMachine {
             Init => SettingUp,
 
             SettingUp | Recovering => {
-                set_all_rooms_to_growing_sync_mode(sliding_sync).await?;
+                let batch_size = self.growing_batch_size.load(Ordering::SeqCst);
+                set_all_rooms_to_growing_sync_mode(sliding_sync, batch_size).await?;
                 Running
             }
 
@@ -165,10 +180,13 @@ impl StateMachine {
     }
 }
 
-async fn set_all_rooms_to_growing_sync_mode(sliding_sync: &SlidingSync) -> Result<(), Error> {
+async fn set_all_rooms_to_growing_sync_mode(
+    sliding_sync: &SlidingSync,
+    batch_size: u32,
+) -> Result<(), Error> {
     sliding_sync
         .on_list(ALL_ROOMS_LIST_NAME, |list| {
-            list.set_sync_mode(SlidingSyncMode::new_growing(ALL_ROOMS_DEFAULT_GROWING_BATCH_SIZE));
+            list.set_sync_mode(SlidingSyncMode::new_growing(batch_size));
 
             ready(())
         })
@@ -388,7 +406,9 @@ mod tests {
         );
 
         // Run the action!
-        set_all_rooms_to_growing_sync_mode(sliding_sync).await.unwrap();
+        set_all_rooms_to_growing_sync_mode(sliding_sync, ALL_ROOMS_DEFAULT_GROWING_BATCH_SIZE)
+            .await
+            .unwrap();
 
         // List is still present, in Growing mode.
         assert_eq!(

Modified file: crates/matrix-sdk-ui/src/sync_service.rs+16 additions@@ -797,6 +797,9 @@ pub struct SyncServiceBuilder {
     /// State events the room list service requests on top of its defaults.
     room_list_extra_required_state: Vec<(StateEventType, String)>,
 
+    /// How many rooms each step of the room list's growing sync asks for.
+    room_list_growing_batch_size: Option<u32>,
+
     /// The parent tracing span to use for the tasks within this service.
     ///
     /// Normally this will be [`Span::none`], but it may be useful to assign a
@@ -815,6 +818,7 @@ impl SyncServiceBuilder {
             room_list_conn_id: DEFAULT_CONNECTION_ID.to_owned(),
             room_list_timeline_limit: DEFAULT_LIST_TIMELINE_LIMIT,
             room_list_extra_required_state: Vec::new(),
+            room_list_growing_batch_size: None,
             parent_span: Span::none(),
         }
     }
@@ -865,6 +869,14 @@ impl SyncServiceBuilder {
         self
     }
 
+    /// How many rooms each step of the room list's growing sync asks for, 100
+    /// by default. Servers that resend every room in the grown range resend a
+    /// large account's rooms once per step.
+    pub fn with_room_list_growing_batch_size(mut self, batch_size: u32) -> Self {
+        self.room_list_growing_batch_size = Some(batch_size);
+        self
+    }
+
     /// Set the parent tracing span to be used for the tasks within this
     /// service.
     pub fn with_parent_span(mut self, parent_span: Span) -> Self {
@@ -886,6 +898,7 @@ impl SyncServiceBuilder {
             room_list_conn_id,
             room_list_timeline_limit,
             room_list_extra_required_state,
+            room_list_growing_batch_size,
             parent_span,
         } = self;
 
@@ -900,6 +913,9 @@ impl SyncServiceBuilder {
             room_list_response_commit_hook,
         )
         .await?;
+        if let Some(batch_size) = room_list_growing_batch_size {
+            room_list.set_growing_batch_size(batch_size);
+        }
 
         let encryption_sync = Arc::new(EncryptionSyncService::new(client, None).await?);

matrix-rust-sdk

Commit a0e7d274a279

Commit `a0e7d274a279`