chore(spaces): introduce a SpaceServiceRoom

Author: stefanceriu

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

@@ -31,10 +31,10 @@ impl RoomPreview {
             avatar_url: info.avatar_url.as_ref().map(|url| url.to_string()),
             num_joined_members: info.num_joined_members,
             num_active_members: info.num_active_members,
-            room_type: info.room_type.as_ref().into(),
+            room_type: info.room_type.clone().into(),
             is_history_world_readable: info.is_world_readable,
             membership: info.state.map(|state| state.into()),
-            join_rule: info.join_rule.as_ref().map(Into::into),
+            join_rule: info.join_rule.clone().map(Into::into),
             is_direct: info.is_direct,
             heroes: info
                 .heroes
@@ -116,8 +116,8 @@ pub struct RoomPreviewInfo {
     pub heroes: Option<Vec<RoomHero>>,
 }
 
-impl From<&JoinRuleSummary> for JoinRule {
-    fn from(join_rule: &JoinRuleSummary) -> Self {
+impl From<JoinRuleSummary> for JoinRule {
+    fn from(join_rule: JoinRuleSummary) -> Self {
         match join_rule {
             JoinRuleSummary::Invite => JoinRule::Invite,
             JoinRuleSummary::Knock => JoinRule::Knock,
@@ -153,8 +153,8 @@ pub enum RoomType {
     Custom { value: String },
 }
 
-impl From<Option<&RumaRoomType>> for RoomType {
-    fn from(value: Option<&RumaRoomType>) -> Self {
+impl From<Option<RumaRoomType>> for RoomType {
+    fn from(value: Option<RumaRoomType>) -> Self {
         match value {
             Some(RumaRoomType::Space) => RoomType::Space,
             Some(RumaRoomType::_Custom(_)) => RoomType::Custom {

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

@@ -12,10 +12,17 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use matrix_sdk_ui::spaces::SpaceService as UISpaceService;
+use matrix_sdk_ui::spaces::{
+    SpaceService as UISpaceService, SpaceServiceRoom as UISpaceServiceRoom,
+};
 use ruma::RoomId;
 
-use crate::error::ClientError;
+use crate::{
+    client::JoinRule,
+    error::ClientError,
+    room::{Membership, RoomHero},
+    room_preview::RoomType,
+};
 
 #[derive(uniffi::Object)]
 pub struct SpaceService {
@@ -32,17 +39,53 @@ impl SpaceService {
 #[matrix_sdk_ffi_macros::export]
 impl SpaceService {
     /// Get the list of joined spaces.
-    pub fn joined_spaces(&self) -> Vec<String> {
-        self.inner.joined_spaces().into_iter().map(|id| id.to_string()).collect()
+    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(
         &self,
         space_id: String,
-    ) -> Result<Vec<String>, ClientError> {
+    ) -> Result<Vec<SpaceServiceRoom>, ClientError> {
         let space_id = RoomId::parse(space_id)?;
         let children = self.inner.top_level_children_for(space_id).await?;
-        Ok(children.into_iter().map(|id| id.to_string()).collect())
+        Ok(children.into_iter().map(Into::into).collect())
+    }
+}
+
+#[derive(uniffi::Record)]
+pub struct SpaceServiceRoom {
+    pub room_id: String,
+    pub canonical_alias: Option<String>,
+    pub name: Option<String>,
+    pub topic: Option<String>,
+    pub avatar_url: Option<String>,
+    pub room_type: RoomType,
+    pub num_joined_members: u64,
+    pub join_rule: Option<JoinRule>,
+    pub world_readable: Option<bool>,
+    pub guest_can_join: bool,
+
+    pub state: Option<Membership>,
+    pub heroes: Option<Vec<RoomHero>>,
+}
+
+impl From<UISpaceServiceRoom> for SpaceServiceRoom {
+    fn from(room: UISpaceServiceRoom) -> Self {
+        Self {
+            room_id: room.room_id.into(),
+            canonical_alias: room.canonical_alias.map(|alias| alias.into()),
+            name: room.name,
+            topic: room.topic,
+            avatar_url: room.avatar_url.map(|url| url.into()),
+            room_type: room.room_type.into(),
+            num_joined_members: room.num_joined_members,
+            join_rule: room.join_rule.map(Into::into),
+            world_readable: room.world_readable,
+            guest_can_join: room.guest_can_join,
+            state: room.state.map(Into::into),
+            heroes: room.heroes.map(|heroes| heroes.into_iter().map(Into::into).collect()),
+        }
     }
 }

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

@@ -20,6 +20,10 @@ use matrix_sdk::{Client, Error};
 use ruma::OwnedRoomId;
 use ruma::api::client::space::get_hierarchy;
 
+pub use crate::spaces::room::SpaceServiceRoom;
+
+pub mod room;
+
 pub struct SpaceService {
     client: Client,
 }
@@ -29,25 +33,29 @@ impl SpaceService {
         Self { client }
     }
 
-    pub fn joined_spaces(&self) -> Vec<OwnedRoomId> {
+    pub fn joined_spaces(&self) -> Vec<SpaceServiceRoom> {
         self.client
             .joined_rooms()
             .into_iter()
-            .filter_map(|room| if room.is_space() { Some(room.room_id().to_owned()) } else { None })
-            .collect()
+            .filter_map(|room| if room.is_space() { Some(room) } else { None })
+            .map(|room| SpaceServiceRoom::new_from_known(room))
+            .collect::<Vec<_>>()
     }
 
     pub async fn top_level_children_for(
         &self,
         space_id: OwnedRoomId,
-    ) -> Result<Vec<OwnedRoomId>, Error> {
+    ) -> Result<Vec<SpaceServiceRoom>, Error> {
         let request = get_hierarchy::v1::Request::new(space_id.clone());
 
         let result = self.client.send(request).await?;
 
-        println!("Top level children for space {}: {:?}", space_id, result.rooms);
-
-        Ok(vec![])
+        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<_>>())
     }
 }
 
@@ -133,7 +141,7 @@ mod tests {
 
         // All joined
         assert_eq!(
-            space_service.joined_spaces(),
+            space_service.joined_spaces().iter().map(|s| s.room_id.to_owned()).collect::<Vec<_>>(),
             vec![child_space_id_1, child_space_id_2, parent_space_id]
         );
 

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

@@ -0,0 +1,76 @@
+// Copyright 2025 The Matrix.org Foundation C.I.C.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for that specific language governing permissions and
+// 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};
+
+#[derive(Debug)]
+pub struct SpaceServiceRoom {
+    pub room_id: OwnedRoomId,
+    pub canonical_alias: Option<OwnedRoomAliasId>,
+    pub name: Option<String>,
+    pub topic: Option<String>,
+    pub avatar_url: Option<OwnedMxcUri>,
+    pub room_type: Option<RoomType>,
+    pub num_joined_members: u64,
+    pub join_rule: Option<JoinRuleSummary>,
+    pub world_readable: Option<bool>,
+    pub guest_can_join: bool,
+
+    pub state: Option<RoomState>,
+    pub heroes: Option<Vec<RoomHero>>,
+}
+
+impl SpaceServiceRoom {
+    pub fn new_from_summary(summary: &RoomSummary, known_room: Option<Room>) -> Self {
+        Self {
+            room_id: summary.room_id.clone(),
+            canonical_alias: summary.canonical_alias.clone(),
+            name: summary.name.clone(),
+            topic: summary.topic.clone(),
+            avatar_url: summary.avatar_url.clone(),
+            room_type: summary.room_type.clone(),
+            num_joined_members: summary.num_joined_members.into(),
+            join_rule: Some(summary.join_rule.clone()),
+            world_readable: Some(summary.world_readable),
+            guest_can_join: summary.guest_can_join,
+            state: known_room.as_ref().map(|r| r.state()),
+            heroes: known_room.map(|r| r.heroes()),
+        }
+    }
+
+    pub fn new_from_known(known_room: Room) -> Self {
+        let room_info = known_room.clone_info();
+
+        Self {
+            room_id: room_info.room_id().to_owned(),
+            canonical_alias: room_info.canonical_alias().map(ToOwned::to_owned),
+            name: room_info.name().map(ToOwned::to_owned),
+            topic: room_info.topic().map(ToOwned::to_owned),
+            avatar_url: room_info.avatar_url().map(ToOwned::to_owned),
+            room_type: room_info.room_type().cloned(),
+            num_joined_members: known_room.joined_members_count(),
+            join_rule: room_info.join_rule().cloned().map(Into::into),
+            world_readable: room_info
+                .history_visibility()
+                .map(|vis| *vis == HistoryVisibility::WorldReadable),
+            guest_can_join: known_room.guest_access() == GuestAccess::CanJoin,
+            state: Some(known_room.state()),
+            heroes: Some(room_info.heroes().to_vec()),
+        }
+    }
+}