Invites room summary fallback

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

@@ -886,6 +886,24 @@ impl Client {
         self.inner.rooms().into_iter().map(|room| Arc::new(Room::new(room))).collect()
     }
 
+    /// Get a room by its ID.
+    ///
+    /// # Arguments
+    ///
+    /// * `room_id` - The ID of the room to get.
+    ///
+    /// # Returns
+    ///
+    /// A `Result` containing an optional room, or a `ClientError`.
+    /// This method will not initialize the room's timeline or populate it with
+    /// events.
+    pub fn get_room(&self, room_id: String) -> Result<Option<Arc<Room>>, ClientError> {
+        let room_id = RoomId::parse(room_id)?;
+        let sdk_room = self.inner.get_room(&room_id);
+        let room = sdk_room.map(|room| Arc::new(Room::new(room)));
+        Ok(room)
+    }
+
     pub fn get_dm_room(&self, user_id: String) -> Result<Option<Arc<Room>>, ClientError> {
         let user_id = UserId::parse(user_id)?;
         let sdk_room = self.inner.get_dm_room(&user_id);

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

@@ -161,21 +161,6 @@ impl Room {
         self.inner.active_room_call_participants().iter().map(|u| u.to_string()).collect()
     }
 
-    /// For rooms one is invited to, retrieves the room member information for
-    /// the user who invited the logged-in user to a room.
-    pub async fn inviter(&self) -> Option<RoomMember> {
-        if self.inner.state() == RoomState::Invited {
-            self.inner
-                .invite_details()
-                .await
-                .ok()
-                .and_then(|a| a.inviter)
-                .and_then(|m| m.try_into().ok())
-        } else {
-            None
-        }
-    }
-
     /// Forces the currently active room key, which is used to encrypt messages,
     /// to be rotated.
     ///

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

@@ -573,24 +573,6 @@ impl RoomListItem {
         self.inner.inner_room().state().into()
     }
 
-    /// Builds a `Room` FFI from an invited room without initializing its
-    /// internal timeline.
-    ///
-    /// An error will be returned if the room is a state different than invited.
-    ///
-    /// ⚠️ Holding on to this room instance after it has been joined is not
-    /// safe. Use `full_room` instead.
-    #[deprecated(note = "Please use `preview_room` instead.")]
-    fn invited_room(&self) -> Result<Arc<Room>, RoomListError> {
-        if !matches!(self.membership(), Membership::Invited) {
-            return Err(RoomListError::IncorrectRoomMembership {
-                expected: vec![Membership::Invited],
-                actual: self.membership(),
-            });
-        }
-        Ok(Arc::new(Room::new(self.inner.inner_room().clone())))
-    }
-
     /// Builds a `RoomPreview` from a room list item. This is intended for
     /// invited, knocked or banned rooms.
     async fn preview_room(&self, via: Vec<String>) -> Result<Arc<RoomPreview>, ClientError> {

crates/matrix-sdk/src/room_preview.rs

@@ -31,7 +31,7 @@ use ruma::{
 use tokio::try_join;
 use tracing::{instrument, warn};
 
-use crate::{room_directory_search::RoomDirectorySearch, Client, Room};
+use crate::{room_directory_search::RoomDirectorySearch, Client, Error, Room};
 
 /// The preview of a room, be it invited/joined/left, or not.
 #[derive(Debug, Clone)]
@@ -172,8 +172,21 @@ impl RoomPreview {
             }
         }
 
-        // Resort to using the room state endpoint, as well as the joined members one.
-        Self::from_state_events(client, &room_id).await
+        // Try using the room state endpoint, as well as the joined members one.
+        match Self::from_state_events(client, &room_id).await {
+            Ok(res) => return Ok(res),
+            Err(err) => {
+                warn!("error when building room preview from state events: {err}");
+            }
+        }
+
+        // Finally, if everything else fails, try to build the room from information
+        // that the client itself might have about it.
+        if let Some(room) = client.get_room(&room_id) {
+            Ok(Self::from_known_room(&room).await)
+        } else {
+            Err(Error::InsufficientData)
+        }
     }
 
     /// Get a [`RoomPreview`] by searching in the room directory for the

crates/matrix-sdk/tests/integration/room_preview.rs

@@ -50,6 +50,28 @@ async fn test_room_preview_leave_invited() {
     assert_eq!(client.get_room(room_id).unwrap().state(), RoomState::Left);
 }
 
+#[async_test]
+async fn test_room_preview_invite_leave_room_summary_disabled() {
+    let (client, server) = logged_in_client_with_server().await;
+    let room_id = room_id!("!room:localhost");
+
+    let mut sync_builder = SyncResponseBuilder::new();
+    sync_builder.add_invited_room(InvitedRoomBuilder::new(room_id));
+
+    mock_sync(&server, sync_builder.build_json_sync_response(), None).await;
+    client.sync_once(SyncSettings::default()).await.unwrap();
+    server.reset().await;
+
+    mock_leave(room_id, &server).await;
+
+    let room_preview = client.get_room_preview(room_id.into(), Vec::new()).await.unwrap();
+    assert_eq!(room_preview.state.unwrap(), RoomState::Invited);
+
+    client.get_room(room_id).unwrap().leave().await.unwrap();
+
+    assert_eq!(client.get_room(room_id).unwrap().state(), RoomState::Left);
+}
+
 #[async_test]
 async fn test_room_preview_leave_knocked() {
     let (client, server) = logged_in_client_with_server().await;