Have the SpaceServiceRoomList publish updates as known room states change i.e. they get joined or left.

Author: stefanceriu

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

@@ -49,7 +49,12 @@ impl SpaceService {
         self.inner.joined_spaces().into_iter().map(Into::into).collect()
     }
 
-    pub fn top_level_children_for(
+    #[allow(clippy::unused_async)]
+    // This method doesn't need to be async but if its not the FFI layer panics
+    // with "there is no no reactor running, must be called from the context
+    // of a Tokio 1.x runtime" error because the underlying constructor spawns
+    // an async task.
+    pub async fn space_room_list(
         &self,
         space_id: String,
     ) -> Result<SpaceServiceRoomList, ClientError> {

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

@@ -90,7 +90,7 @@ impl RoomUpdates {
     /// Iterate over all room IDs, from [`RoomUpdates::left`],
     /// [`RoomUpdates::joined`], [`RoomUpdates::invited`] and
     /// [`RoomUpdates::knocked`].
-    pub(crate) fn iter_all_room_ids(&self) -> impl Iterator<Item = &OwnedRoomId> {
+    pub fn iter_all_room_ids(&self) -> impl Iterator<Item = &OwnedRoomId> {
         self.left
             .keys()
             .chain(self.joined.keys())

crates/matrix-sdk-ui/src/spaces/mod.rs

@@ -97,7 +97,7 @@ impl SpaceService {
             .then(|room| async move {
                 let ok = if let Ok(parents) = room.parent_spaces().await {
                     pin_mut!(parents);
-                    parents.any(|p| p.is_ok()).await == false
+                    !parents.any(|p| p.is_ok()).await
                 } else {
                     false
                 };
@@ -115,19 +115,17 @@ impl SpaceService {
 #[cfg(test)]
 mod tests {
     use assert_matches2::assert_let;
+    use futures_util::pin_mut;
     use matrix_sdk::{room::ParentSpace, test_utils::mocks::MatrixMockServer};
     use matrix_sdk_test::{
         JoinedRoomBuilder, LeftRoomBuilder, async_test, event_factory::EventFactory,
     };
     use ruma::{RoomVersionId, room::RoomType, room_id};
+    use stream_assert::{assert_next_eq, assert_pending};
     use tokio_stream::StreamExt;
 
     use super::*;
 
-    use futures_util::pin_mut;
-
-    use stream_assert::{assert_next_eq, assert_pending};
-
     #[async_test]
     async fn test_spaces_hierarchy() {
         let server = MatrixMockServer::new().await;

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

@@ -15,8 +15,11 @@
 use std::sync::Mutex;
 
 use eyeball::{SharedObservable, Subscriber};
+use futures_util::pin_mut;
 use matrix_sdk::{Client, Error, paginators::PaginationToken};
 use ruma::{OwnedRoomId, api::client::space::get_hierarchy};
+use tokio::task::JoinHandle;
+use tracing::error;
 
 use crate::spaces::SpaceServiceRoom;
 
@@ -36,18 +39,60 @@ pub struct SpaceServiceRoomList {
     pagination_state: SharedObservable<SpaceServiceRoomListPaginationState>,
 
     rooms: SharedObservable<Vec<SpaceServiceRoom>>,
+
+    room_update_handle: JoinHandle<()>,
 }
 
+impl Drop for SpaceServiceRoomList {
+    fn drop(&mut self) {
+        self.room_update_handle.abort();
+    }
+}
 impl SpaceServiceRoomList {
     pub fn new(client: Client, parent_space_id: OwnedRoomId) -> Self {
+        let rooms = SharedObservable::new(Vec::<SpaceServiceRoom>::new());
+
+        let client_clone = client.clone();
+        let rooms_clone = rooms.clone();
+        let all_room_updates_receiver = client.subscribe_to_all_room_updates();
+
+        let handle = tokio::spawn(async move {
+            pin_mut!(all_room_updates_receiver);
+
+            loop {
+                match all_room_updates_receiver.recv().await {
+                    Ok(updates) => {
+                        let mut new_rooms = rooms_clone.get();
+
+                        updates.iter_all_room_ids().for_each(|updated_room_id| {
+                            if let Some(room) =
+                                new_rooms.iter_mut().find(|room| &room.room_id == updated_room_id)
+                                && let Some(update_room) = client_clone.get_room(updated_room_id)
+                            {
+                                *room = SpaceServiceRoom::new_from_known(update_room);
+                            }
+                        });
+
+                        if new_rooms != rooms_clone.get() {
+                            rooms_clone.set(new_rooms);
+                        }
+                    }
+                    Err(err) => {
+                        error!("error when listening to room updates: {err}");
+                    }
+                }
+            }
+        });
+
         Self {
             client,
             parent_space_id,
             token: Mutex::new(None.into()),
             pagination_state: SharedObservable::new(SpaceServiceRoomListPaginationState::Idle {
                 end_reached: false,
             }),
-            rooms: SharedObservable::new(Vec::new()),
+            rooms,
+            room_update_handle: handle,
         }
     }
 
@@ -132,13 +177,13 @@ impl SpaceServiceRoomList {
 mod tests {
     use assert_matches2::assert_matches;
     use futures_util::pin_mut;
-    use matrix_sdk::test_utils::mocks::MatrixMockServer;
-    use matrix_sdk_test::async_test;
+    use matrix_sdk::{RoomState, test_utils::mocks::MatrixMockServer};
+    use matrix_sdk_test::{JoinedRoomBuilder, LeftRoomBuilder, async_test};
     use ruma::{
         room::{JoinRuleSummary, RoomSummary},
         room_id, uint,
     };
-    use stream_assert::{assert_next_eq, assert_next_matches, assert_pending};
+    use stream_assert::{assert_next_eq, assert_next_matches, assert_pending, assert_ready};
 
     use crate::spaces::{
         SpaceService, SpaceServiceRoom, room_list::SpaceServiceRoomListPaginationState,
@@ -220,4 +265,58 @@ mod tests {
             ]
         );
     }
+
+    #[async_test]
+    async fn test_room_state_updates() {
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
+        let space_service = SpaceService::new(client.clone()).await;
+
+        let parent_space_id = room_id!("!parent_space:example.org");
+        let child_room_id_1 = room_id!("!1:example.org");
+        let child_room_id_2 = room_id!("!2:example.org");
+
+        server
+            .mock_get_hierarchy()
+            .ok_with_room_ids(vec![child_room_id_1, child_room_id_2])
+            .mount()
+            .await;
+
+        let room_list = space_service.space_room_list(parent_space_id.to_owned());
+
+        room_list.paginate().await.unwrap();
+
+        // This space contains 2 rooms
+        assert_eq!(room_list.rooms().first().unwrap().room_id, child_room_id_1);
+        assert_eq!(room_list.rooms().last().unwrap().room_id, child_room_id_2);
+
+        // and we don't know about either of them
+        assert_eq!(room_list.rooms().first().unwrap().state, None);
+        assert_eq!(room_list.rooms().last().unwrap().state, None);
+
+        let rooms_subscriber = room_list.subscribe_to_room_updates();
+        pin_mut!(rooms_subscriber);
+        assert_pending!(rooms_subscriber);
+
+        // Joining one of them though
+        server.sync_room(&client, JoinedRoomBuilder::new(child_room_id_1)).await;
+
+        // Results in an update being pushed through
+        assert_ready!(rooms_subscriber);
+        assert_eq!(room_list.rooms().first().unwrap().state, Some(RoomState::Joined));
+        assert_eq!(room_list.rooms().last().unwrap().state, None);
+
+        // Same for the second one
+        server.sync_room(&client, JoinedRoomBuilder::new(child_room_id_2)).await;
+        assert_ready!(rooms_subscriber);
+        assert_eq!(room_list.rooms().first().unwrap().state, Some(RoomState::Joined));
+        assert_eq!(room_list.rooms().last().unwrap().state, Some(RoomState::Joined));
+
+        // And when leaving them
+        server.sync_room(&client, LeftRoomBuilder::new(child_room_id_1)).await;
+        server.sync_room(&client, LeftRoomBuilder::new(child_room_id_2)).await;
+        assert_ready!(rooms_subscriber);
+        assert_eq!(room_list.rooms().first().unwrap().state, Some(RoomState::Left));
+        assert_eq!(room_list.rooms().last().unwrap().state, Some(RoomState::Left));
+    }
 }