chore(sdk): Rename RoomInfoUpdate into RoomInfoNotableUpdate.

The patch renames `RoomInfoUpdate` to `RoomInfoNotableUpdate`.
The functions, methods or variables whose names start with
`roominfo_update(.*)`` are renamed `room_info_notable_update$1`.

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

@@ -243,7 +243,7 @@ impl RoomList {
         let (entries_stream, dynamic_entries_controller) =
             this.inner.entries_with_dynamic_adapters(
                 page_size.try_into().unwrap(),
-                client.roominfo_update_receiver(),
+                client.room_info_notable_update_receiver(),
             );
 
         // FFI dance to make those values consumable by foreign language, nothing fancy

crates/matrix-sdk-base/src/client.rs

@@ -70,7 +70,7 @@ use crate::RoomMemberships;
 use crate::{
     deserialized_responses::{RawAnySyncOrStrippedTimelineEvent, SyncTimelineEvent},
     error::{Error, Result},
-    rooms::{normal::RoomInfoUpdate, Room, RoomInfo, RoomState},
+    rooms::{normal::RoomInfoNotableUpdate, Room, RoomInfo, RoomState},
     store::{
         ambiguity_map::AmbiguityCache, DynStateStore, MemoryStore, Result as StoreResult,
         StateChanges, StateStoreDataKey, StateStoreDataValue, StateStoreExt, Store, StoreConfig,
@@ -104,7 +104,7 @@ pub struct BaseClient {
     /// A sender that is used to communicate changes to room information. Each
     /// event contains the room and a boolean whether this event should
     /// trigger a room list update.
-    pub(crate) roominfo_update_sender: broadcast::Sender<RoomInfoUpdate>,
+    pub(crate) room_info_notable_update_sender: broadcast::Sender<RoomInfoNotableUpdate>,
 }
 
 #[cfg(not(tarpaulin_include))]
@@ -130,7 +130,8 @@ impl BaseClient {
     /// * `config` - An optional session if the user already has one from a
     ///   previous login call.
     pub fn with_store_config(config: StoreConfig) -> Self {
-        let (roominfo_update_sender, _roominfo_update_receiver) = broadcast::channel(100);
+        let (room_info_notable_update_sender, _room_info_notable_update_receiver) =
+            broadcast::channel(100);
 
         BaseClient {
             store: Store::new(config.state_store),
@@ -139,7 +140,7 @@ impl BaseClient {
             #[cfg(feature = "e2e-encryption")]
             olm_machine: Default::default(),
             ignore_user_list_changes: Default::default(),
-            roominfo_update_sender,
+            room_info_notable_update_sender,
         }
     }
 
@@ -183,7 +184,11 @@ impl BaseClient {
     /// Lookup the Room for the given RoomId, or create one, if it didn't exist
     /// yet in the store
     pub fn get_or_create_room(&self, room_id: &RoomId, room_state: RoomState) -> Room {
-        self.store.get_or_create_room(room_id, room_state, self.roominfo_update_sender.clone())
+        self.store.get_or_create_room(
+            room_id,
+            room_state,
+            self.room_info_notable_update_sender.clone(),
+        )
     }
 
     /// Get a reference to the store.
@@ -225,7 +230,9 @@ impl BaseClient {
         >,
     ) -> Result<()> {
         debug!(user_id = ?session_meta.user_id, device_id = ?session_meta.device_id, "Restoring login");
-        self.store.set_session_meta(session_meta.clone(), &self.roominfo_update_sender).await?;
+        self.store
+            .set_session_meta(session_meta.clone(), &self.room_info_notable_update_sender)
+            .await?;
 
         #[cfg(feature = "e2e-encryption")]
         self.regenerate_olm(custom_account).await?;
@@ -754,7 +761,7 @@ impl BaseClient {
         let room = self.store.get_or_create_room(
             room_id,
             RoomState::Joined,
-            self.roominfo_update_sender.clone(),
+            self.room_info_notable_update_sender.clone(),
         );
 
         if room.state() != RoomState::Joined {
@@ -781,7 +788,7 @@ impl BaseClient {
         let room = self.store.get_or_create_room(
             room_id,
             RoomState::Left,
-            self.roominfo_update_sender.clone(),
+            self.room_info_notable_update_sender.clone(),
         );
 
         if room.state() != RoomState::Left {
@@ -857,7 +864,7 @@ impl BaseClient {
             let room = self.store.get_or_create_room(
                 &room_id,
                 RoomState::Joined,
-                self.roominfo_update_sender.clone(),
+                self.room_info_notable_update_sender.clone(),
             );
 
             let mut room_info = room.clone_info();
@@ -970,7 +977,7 @@ impl BaseClient {
             let room = self.store.get_or_create_room(
                 &room_id,
                 RoomState::Left,
-                self.roominfo_update_sender.clone(),
+                self.room_info_notable_update_sender.clone(),
             );
 
             let mut room_info = room.clone_info();
@@ -1029,7 +1036,7 @@ impl BaseClient {
             let room = self.store.get_or_create_room(
                 &room_id,
                 RoomState::Invited,
-                self.roominfo_update_sender.clone(),
+                self.room_info_notable_update_sender.clone(),
             );
 
             let mut room_info = room.clone_info();
@@ -1476,13 +1483,11 @@ impl BaseClient {
             .collect()
     }
 
-    /// Returns a new receiver that gets events for all future room info
-    /// updates.
+    /// Returns a new receiver that gets future room info notable updates.
     ///
-    /// Each event contains the room and a boolean whether this event should
-    /// trigger a room list update.
-    pub fn roominfo_update_receiver(&self) -> broadcast::Receiver<RoomInfoUpdate> {
-        self.roominfo_update_sender.subscribe()
+    /// Learn more by reading the [`RoomInfoNotableUpdate`] type.
+    pub fn room_info_notable_update_receiver(&self) -> broadcast::Receiver<RoomInfoNotableUpdate> {
+        self.room_info_notable_update_sender.subscribe()
     }
 }
 

crates/matrix-sdk-base/src/lib.rs

@@ -52,8 +52,9 @@ pub use http;
 pub use matrix_sdk_crypto as crypto;
 pub use once_cell;
 pub use rooms::{
-    DisplayName, Room, RoomCreateWithCreatorEventContent, RoomHero, RoomInfo, RoomInfoUpdate,
-    RoomMember, RoomMemberships, RoomState, RoomStateFilter,
+    DisplayName, Room, RoomCreateWithCreatorEventContent, RoomHero, RoomInfo,
+    RoomInfoNotableUpdate, RoomMember, RoomMemberships, RoomState,
+    RoomStateFilter,
 };
 pub use store::{
     ComposerDraft, ComposerDraftType, StateChanges, StateStore, StateStoreDataKey,

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

@@ -11,7 +11,10 @@ use std::{
 
 use bitflags::bitflags;
 pub use members::RoomMember;
-pub use normal::{Room, RoomHero, RoomInfo, RoomInfoUpdate, RoomState, RoomStateFilter};
+pub use normal::{
+    Room, RoomHero, RoomInfo, RoomInfoNotableUpdate, RoomInfoNotableUpdateReasons, RoomState,
+    RoomStateFilter,
+};
 use ruma::{
     assign,
     events::{

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

@@ -69,11 +69,17 @@ use crate::{
     MinimalStateEvent, OriginalMinimalStateEvent, RoomMemberships,
 };
 
-/// A summary of changes to room information.
+/// Indicates that a notable update of `RoomInfo` has been applied, and why.
 ///
-/// It also indicates whether this update should update the room list.
+/// A room info notable update is an update that can be interested for other
+/// parts of the code. This mechanism is used in coordination with
+/// [`BaseClient::room_info_notable_update_receiver`][baseclient] (and
+/// `Room::inner` plus `Room::room_info_notable_update_sender`) where `RoomInfo`
+/// can be observed and some of its updates can be spread to listeners.
+///
+/// [baseclient]: crate::BaseClient::room_info_notable_update_receiver
 #[derive(Debug, Clone)]
-pub struct RoomInfoUpdate {
+pub struct RoomInfoNotableUpdate {
     /// The room which was updated.
     pub room_id: OwnedRoomId,
     /// Whether this event should trigger the room list to update.
@@ -90,7 +96,7 @@ pub struct Room {
     room_id: OwnedRoomId,
     own_user_id: OwnedUserId,
     inner: SharedObservable<RoomInfo>,
-    roominfo_update_sender: broadcast::Sender<RoomInfoUpdate>,
+    room_info_notable_update_sender: broadcast::Sender<RoomInfoNotableUpdate>,
     store: Arc<DynStateStore>,
 
     /// The most recent few encrypted events. When the keys come through to
@@ -190,17 +196,17 @@ impl Room {
         store: Arc<DynStateStore>,
         room_id: &RoomId,
         room_state: RoomState,
-        roominfo_update_sender: broadcast::Sender<RoomInfoUpdate>,
+        room_info_notable_update_sender: broadcast::Sender<RoomInfoNotableUpdate>,
     ) -> Self {
         let room_info = RoomInfo::new(room_id, room_state);
-        Self::restore(own_user_id, store, room_info, roominfo_update_sender)
+        Self::restore(own_user_id, store, room_info, room_info_notable_update_sender)
     }
 
     pub(crate) fn restore(
         own_user_id: &UserId,
         store: Arc<DynStateStore>,
         room_info: RoomInfo,
-        roominfo_update_sender: broadcast::Sender<RoomInfoUpdate>,
+        room_info_notable_update_sender: broadcast::Sender<RoomInfoNotableUpdate>,
     ) -> Self {
         Self {
             own_user_id: own_user_id.into(),
@@ -211,7 +217,7 @@ impl Room {
             latest_encrypted_events: Arc::new(SyncRwLock::new(RingBuffer::new(
                 Self::MAX_ENCRYPTED_EVENTS,
             ))),
-            roominfo_update_sender,
+            room_info_notable_update_sender,
         }
     }
 
@@ -762,9 +768,10 @@ impl Room {
         self.inner.set(room_info);
 
         // Ignore error if no receiver exists.
-        let _ = self
-            .roominfo_update_sender
-            .send(RoomInfoUpdate { room_id: self.room_id.clone(), trigger_room_list_update });
+        let _ = self.room_info_notable_update_sender.send(RoomInfoNotableUpdate {
+            room_id: self.room_id.clone(),
+            trigger_room_list_update,
+        });
     }
 
     /// Get the `RoomMember` with the given `user_id`.
@@ -2296,7 +2303,7 @@ mod tests {
 
     #[async_test]
     #[cfg(feature = "experimental-sliding-sync")]
-    async fn test_setting_the_latest_event_doesnt_cause_a_room_info_update() {
+    async fn test_setting_the_latest_event_doesnt_cause_a_room_info_notable_update() {
         // Given a room,
 
         let client = BaseClient::new();

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

@@ -475,7 +475,7 @@ impl BaseClient {
             let room = store.get_or_create_room(
                 room_id,
                 RoomState::Invited,
-                self.roominfo_update_sender.clone(),
+                self.room_info_notable_update_sender.clone(),
             );
             let mut room_info = room.clone_info();
 
@@ -497,7 +497,7 @@ impl BaseClient {
             let room = store.get_or_create_room(
                 room_id,
                 RoomState::Joined,
-                self.roominfo_update_sender.clone(),
+                self.room_info_notable_update_sender.clone(),
             );
             let mut room_info = room.clone_info();
 

crates/matrix-sdk-base/src/store/mod.rs

@@ -59,7 +59,7 @@ use ruma::{
 use tokio::sync::{broadcast, Mutex, RwLock};
 
 use crate::{
-    rooms::{normal::RoomInfoUpdate, RoomInfo, RoomState},
+    rooms::{normal::RoomInfoNotableUpdate, RoomInfo, RoomState},
     MinimalRoomMemberEvent, Room, RoomStateFilter, SessionMeta,
 };
 
@@ -178,7 +178,7 @@ impl Store {
     pub async fn set_session_meta(
         &self,
         session_meta: SessionMeta,
-        roominfo_update_sender: &broadcast::Sender<RoomInfoUpdate>,
+        room_info_notable_update_sender: &broadcast::Sender<RoomInfoNotableUpdate>,
     ) -> Result<()> {
         {
             let room_infos = self.inner.get_room_infos().await?;
@@ -190,7 +190,7 @@ impl Store {
                     &session_meta.user_id,
                     self.inner.clone(),
                     room_info,
-                    roominfo_update_sender.clone(),
+                    room_info_notable_update_sender.clone(),
                 );
                 let new_room_id = new_room.room_id().to_owned();
 
@@ -246,7 +246,7 @@ impl Store {
         &self,
         room_id: &RoomId,
         room_type: RoomState,
-        roominfo_update_sender: broadcast::Sender<RoomInfoUpdate>,
+        room_info_notable_update_sender: broadcast::Sender<RoomInfoNotableUpdate>,
     ) -> Room {
         let user_id =
             &self.session_meta.get().expect("Creating room while not being logged in").user_id;
@@ -255,7 +255,13 @@ impl Store {
             .write()
             .unwrap()
             .get_or_create(room_id, || {
-                Room::new(user_id, self.inner.clone(), room_id, room_type, roominfo_update_sender)
+                Room::new(
+                    user_id,
+                    self.inner.clone(),
+                    room_id,
+                    room_type,
+                    room_info_notable_update_sender,
+                )
             })
             .clone()
     }

crates/matrix-sdk-ui/src/room_list_service/room_list.rs

@@ -25,7 +25,7 @@ use matrix_sdk::{
     executor::{spawn, JoinHandle},
     Client, SlidingSync, SlidingSyncList,
 };
-use matrix_sdk_base::RoomInfoUpdate;
+use matrix_sdk_base::RoomInfoNotableUpdate;
 use tokio::{select, sync::broadcast};
 
 use super::{
@@ -138,7 +138,7 @@ impl RoomList {
     pub fn entries_with_dynamic_adapters(
         &self,
         page_size: usize,
-        roominfo_update_recv: broadcast::Receiver<RoomInfoUpdate>,
+        room_info_notable_update_receiver: broadcast::Receiver<RoomInfoNotableUpdate>,
     ) -> (impl Stream<Item = Vec<VectorDiff<Room>>> + '_, RoomListDynamicEntriesController) {
         let list = self.sliding_sync_list.clone();
 
@@ -161,7 +161,7 @@ impl RoomList {
                 let (raw_values, raw_stream) = self.entries();
 
                 // Combine normal stream events with other updates from rooms
-                let merged_streams = merge_stream_and_receiver(raw_values.clone(), raw_stream, roominfo_update_recv.resubscribe());
+                let merged_streams = merge_stream_and_receiver(raw_values.clone(), raw_stream, room_info_notable_update_receiver.resubscribe());
 
                 let (values, stream) = (raw_values, merged_streams)
                     .filter(filter_fn)
@@ -188,7 +188,7 @@ impl RoomList {
 fn merge_stream_and_receiver(
     mut raw_current_values: Vector<Room>,
     raw_stream: impl Stream<Item = Vec<VectorDiff<Room>>>,
-    mut roominfo_update_recv: broadcast::Receiver<RoomInfoUpdate>,
+    mut room_info_notable_update_receiver: broadcast::Receiver<RoomInfoNotableUpdate>,
 ) -> impl Stream<Item = Vec<VectorDiff<Room>>> {
     stream! {
         pin_mut!(raw_stream);
@@ -211,10 +211,8 @@ fn merge_stream_and_receiver(
                     }
                 }
 
-                Ok(update) = roominfo_update_recv.recv() => {
-                    if !update.trigger_room_list_update {
-                        continue;
-                    }
+                Ok(update) = room_info_notable_update_receiver.recv() => {
+                    let reasons = &update.reasons;
 
                     // Search list for the updated room
                     if let Some(index) = raw_current_values.iter().position(|room| room.room_id() == update.room_id) {

crates/matrix-sdk-ui/tests/integration/room_list_service.rs

@@ -1269,7 +1269,7 @@ async fn test_dynamic_entries_stream() -> Result<(), Error> {
     let all_rooms = room_list.all_rooms().await?;
 
     let (dynamic_entries_stream, dynamic_entries) =
-        all_rooms.entries_with_dynamic_adapters(5, client.roominfo_update_receiver());
+        all_rooms.entries_with_dynamic_adapters(5, client.room_info_notable_update_receiver());
     pin_mut!(dynamic_entries_stream);
 
     sync_then_assert_request_and_fake_response! {
@@ -1663,7 +1663,7 @@ async fn test_room_sorting() -> Result<(), Error> {
     let all_rooms = room_list.all_rooms().await?;
 
     let (stream, dynamic_entries) =
-        all_rooms.entries_with_dynamic_adapters(10, client.roominfo_update_receiver());
+        all_rooms.entries_with_dynamic_adapters(10, client.room_info_notable_update_receiver());
     pin_mut!(stream);
 
     sync_then_assert_request_and_fake_response! {

crates/matrix-sdk/src/client/mod.rs

@@ -35,7 +35,7 @@ use matrix_sdk_base::crypto::store::LockableCryptoStore;
 use matrix_sdk_base::{
     store::DynStateStore,
     sync::{Notification, RoomUpdates},
-    BaseClient, RoomInfoUpdate, RoomState, RoomStateFilter, SendOutsideWasm, SessionMeta,
+    BaseClient, RoomInfoNotableUpdate, RoomState, RoomStateFilter, SendOutsideWasm, SessionMeta,
     SyncOutsideWasm,
 };
 use matrix_sdk_common::instant::Instant;
@@ -487,8 +487,8 @@ impl Client {
     /// Returns a receiver that gets events for each room info update. To watch
     /// for new events, use `receiver.resubscribe()`. Each event contains the
     /// room and a boolean whether this event should trigger a room list update.
-    pub fn roominfo_update_receiver(&self) -> broadcast::Receiver<RoomInfoUpdate> {
-        self.base_client().roominfo_update_receiver()
+    pub fn room_info_notable_update_receiver(&self) -> broadcast::Receiver<RoomInfoNotableUpdate> {
+        self.base_client().room_info_notable_update_receiver()
     }
 
     /// Performs a search for users.

labs/multiverse/src/main.rs

@@ -195,8 +195,8 @@ impl App {
             let ui_rooms = ur;
             let timelines = t;
 
-            let (stream, entries_controller) =
-                all_rooms.entries_with_dynamic_adapters(50_000, client.roominfo_update_receiver());
+            let (stream, entries_controller) = all_rooms
+                .entries_with_dynamic_adapters(50_000, client.room_info_notable_update_receiver());
             entries_controller.set_filter(Box::new(new_filter_non_left()));
 
             pin_mut!(stream);

testing/matrix-sdk-integration-testing/src/tests/sliding_sync/room.rs

@@ -802,7 +802,7 @@ async fn test_delayed_decryption_latest_event() -> Result<()> {
 
     let alice_all_rooms = alice_sync_service.room_list_service().all_rooms().await.unwrap();
     let (stream, entries) =
-        alice_all_rooms.entries_with_dynamic_adapters(10, alice.roominfo_update_receiver());
+        alice_all_rooms.entries_with_dynamic_adapters(10, alice.room_info_notable_update_receiver());
     entries.set_filter(Box::new(new_filter_all(vec![])));
     pin_mut!(stream);
 
@@ -866,7 +866,7 @@ async fn test_delayed_decryption_latest_event() -> Result<()> {
 }
 
 #[tokio::test]
-async fn test_roominfo_update_deduplication() -> Result<()> {
+async fn test_room_info_notable_update_deduplication() -> Result<()> {
     let alice = TestClientBuilder::new("alice").use_sqlite().build().await?;
     let bob = TestClientBuilder::new("bob").use_sqlite().build().await?;
 
@@ -928,7 +928,7 @@ async fn test_roominfo_update_deduplication() -> Result<()> {
 
     let alice_all_rooms = alice_sync_service.room_list_service().all_rooms().await.unwrap();
     let (stream, entries) =
-        alice_all_rooms.entries_with_dynamic_adapters(10, alice.roominfo_update_receiver());
+        alice_all_rooms.entries_with_dynamic_adapters(10, alice.room_info_notable_update_receiver());
     entries.set_filter(Box::new(new_filter_all(vec![])));
 
     pin_mut!(stream);