Introduce a SpaceServiceRoomList that allows pagination and provides reactive interfaces to its rooms and pagination state.

Author: stefanceriu

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

@@ -12,8 +12,14 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use std::{fmt::Debug, sync::Arc};
+
+use futures_util::{pin_mut, StreamExt};
+use matrix_sdk_common::{SendOutsideWasm, SyncOutsideWasm};
 use matrix_sdk_ui::spaces::{
+    room_list::SpaceServiceRoomListPaginationState as UISpaceServiceRoomListPaginationState,
     SpaceService as UISpaceService, SpaceServiceRoom as UISpaceServiceRoom,
+    SpaceServiceRoomList as UISpaceServiceRoomList,
 };
 use ruma::RoomId;
 
@@ -22,6 +28,8 @@ use crate::{
     error::ClientError,
     room::{Membership, RoomHero},
     room_preview::RoomType,
+    runtime::get_runtime_handle,
+    TaskHandle,
 };
 
 #[derive(uniffi::Object)]
@@ -30,28 +38,104 @@ pub struct SpaceService {
 }
 
 impl SpaceService {
-    /// Create a new instance of `SpaceService`.
     pub fn new(inner: UISpaceService) -> Self {
         Self { inner }
     }
 }
 
 #[matrix_sdk_ffi_macros::export]
 impl SpaceService {
-    /// Get the list of joined spaces.
     pub fn joined_spaces(&self) -> Vec<SpaceServiceRoom> {
         self.inner.joined_spaces().into_iter().map(Into::into).collect()
     }
 
-    /// Get the top-level children for a given space.
-    pub async fn top_level_children_for(
+    pub fn top_level_children_for(
         &self,
         space_id: String,
-    ) -> Result<Vec<SpaceServiceRoom>, ClientError> {
+    ) -> Result<SpaceServiceRoomList, ClientError> {
         let space_id = RoomId::parse(space_id)?;
-        let children = self.inner.top_level_children_for(space_id).await?;
-        Ok(children.into_iter().map(Into::into).collect())
+        Ok(SpaceServiceRoomList::new(self.inner.space_room_list(space_id)))
+    }
+}
+
+#[derive(uniffi::Object)]
+pub struct SpaceServiceRoomList {
+    inner: UISpaceServiceRoomList,
+}
+
+impl SpaceServiceRoomList {
+    pub fn new(inner: UISpaceServiceRoomList) -> Self {
+        Self { inner }
+    }
+}
+
+#[matrix_sdk_ffi_macros::export]
+impl SpaceServiceRoomList {
+    pub fn pagination_state(&self) -> SpaceServiceRoomListPaginationState {
+        self.inner.pagination_state().into()
+    }
+
+    pub fn subscribe_to_pagiation_state_updates(
+        &self,
+        listener: Box<dyn SpaceServiceRoomListPaginationStateListener>,
+    ) {
+        let pagination_state = self.inner.subscribe_to_pagination_state_updates();
+
+        Arc::new(TaskHandle::new(get_runtime_handle().spawn(async move {
+            pin_mut!(pagination_state);
+
+            while let Some(state) = pagination_state.next().await {
+                listener.on_update(state.into());
+            }
+        })));
     }
+
+    pub fn rooms(&self) -> Vec<SpaceServiceRoom> {
+        self.inner.rooms().into_iter().map(Into::into).collect()
+    }
+
+    pub fn subscribe_to_room_update(&self, listener: Box<dyn SpaceServiceRoomListEntriesListener>) {
+        let entries_stream = self.inner.subscribe_to_room_updates();
+
+        Arc::new(TaskHandle::new(get_runtime_handle().spawn(async move {
+            pin_mut!(entries_stream);
+
+            while let Some(rooms) = entries_stream.next().await {
+                listener.on_update(rooms.into_iter().map(Into::into).collect());
+            }
+        })));
+    }
+}
+
+#[derive(uniffi::Enum)]
+pub enum SpaceServiceRoomListPaginationState {
+    Idle { end_reached: bool },
+    Loading,
+}
+
+impl From<UISpaceServiceRoomListPaginationState> for SpaceServiceRoomListPaginationState {
+    fn from(state: UISpaceServiceRoomListPaginationState) -> Self {
+        match state {
+            UISpaceServiceRoomListPaginationState::Idle { end_reached } => {
+                SpaceServiceRoomListPaginationState::Idle { end_reached }
+            }
+            UISpaceServiceRoomListPaginationState::Loading => {
+                SpaceServiceRoomListPaginationState::Loading
+            }
+        }
+    }
+}
+
+#[matrix_sdk_ffi_macros::export(callback_interface)]
+pub trait SpaceServiceRoomListPaginationStateListener:
+    SendOutsideWasm + SyncOutsideWasm + Debug
+{
+    fn on_update(&self, pagination_state: SpaceServiceRoomListPaginationState);
+}
+
+#[matrix_sdk_ffi_macros::export(callback_interface)]
+pub trait SpaceServiceRoomListEntriesListener: SendOutsideWasm + SyncOutsideWasm + Debug {
+    fn on_update(&self, rooms: Vec<SpaceServiceRoom>);
 }
 
 #[derive(uniffi::Record)]

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

@@ -14,15 +14,15 @@
 
 //! High level interfaces for working with Spaces
 //!
-//! See [`SpaceDiscoveryService`] for details.
+//! See [`SpaceService`] for details.
 
-use matrix_sdk::{Client, Error};
+use matrix_sdk::Client;
 use ruma::OwnedRoomId;
-use ruma::api::client::space::get_hierarchy;
 
-pub use crate::spaces::room::SpaceServiceRoom;
+pub use crate::spaces::{room::SpaceServiceRoom, room_list::SpaceServiceRoomList};
 
 pub mod room;
+pub mod room_list;
 
 pub struct SpaceService {
     client: Client,
@@ -38,36 +38,25 @@ impl SpaceService {
             .joined_rooms()
             .into_iter()
             .filter_map(|room| if room.is_space() { Some(room) } else { None })
-            .map(|room| SpaceServiceRoom::new_from_known(room))
+            .map(SpaceServiceRoom::new_from_known)
             .collect::<Vec<_>>()
     }
 
-    pub async fn top_level_children_for(
-        &self,
-        space_id: OwnedRoomId,
-    ) -> Result<Vec<SpaceServiceRoom>, Error> {
-        let request = get_hierarchy::v1::Request::new(space_id.clone());
-
-        let result = self.client.send(request).await?;
-
-        Ok(result
-            .rooms
-            .iter()
-            .map(|room| (&room.summary, self.client.get_room(&room.summary.room_id)))
-            .map(|(summary, room)| SpaceServiceRoom::new_from_summary(summary, room))
-            .collect::<Vec<_>>())
+    pub fn space_room_list(&self, space_id: OwnedRoomId) -> SpaceServiceRoomList {
+        SpaceServiceRoomList::new(self.client.clone(), space_id)
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use assert_matches2::assert_let;
     use matrix_sdk::{room::ParentSpace, test_utils::mocks::MatrixMockServer};
     use matrix_sdk_test::{JoinedRoomBuilder, async_test, event_factory::EventFactory};
     use ruma::{RoomVersionId, room::RoomType, room_id};
     use tokio_stream::StreamExt;
 
+    use super::*;
+
     #[async_test]
     async fn test_spaces_hierarchy() {
         let server = MatrixMockServer::new().await;
@@ -80,9 +69,9 @@ mod tests {
 
         // Given one parent space with 2 children spaces
 
-        let parent_space_id = room_id!("!3:example.org");
-        let child_space_id_1 = room_id!("!1:example.org");
-        let child_space_id_2 = room_id!("!2:example.org");
+        let parent_space_id = room_id!("!parent_space:example.org");
+        let child_space_id_1 = room_id!("!child_space_1:example.org");
+        let child_space_id_2 = room_id!("!child_space_2:example.org");
 
         server
             .sync_room(

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

@@ -13,12 +13,13 @@
 // limitations under the License.
 
 use matrix_sdk::{Room, RoomHero, RoomState};
-use ruma::events::room::guest_access::GuestAccess;
-use ruma::events::room::history_visibility::HistoryVisibility;
-use ruma::room::{JoinRuleSummary, RoomSummary, RoomType};
-use ruma::{OwnedMxcUri, OwnedRoomAliasId, OwnedRoomId};
+use ruma::{
+    OwnedMxcUri, OwnedRoomAliasId, OwnedRoomId,
+    events::room::{guest_access::GuestAccess, history_visibility::HistoryVisibility},
+    room::{JoinRuleSummary, RoomSummary, RoomType},
+};
 
-#[derive(Debug)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct SpaceServiceRoom {
     pub room_id: OwnedRoomId,
     pub canonical_alias: Option<OwnedRoomAliasId>,