feat(ffi): expose a new get_room method on the NotificationClient that will fetch it from its inner in-memory store backed client instead of the parent one.

This is necessary because the `NotificationClient` runs a sliding sync loop and the retrieved data isn't pushed back into the parent client stores (because of cross process locking shenanigans).
This will be used with the previously introduced `org.matrix.msc3401.call.member` required state to check whether a room still has an ongoing call before showing the ringing screen.

Author: stefanceriu

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

@@ -9,6 +9,7 @@ use crate::{
     client::{Client, JoinRule},
     error::ClientError,
     event::TimelineEvent,
+    room::Room,
 };
 
 #[derive(uniffi::Enum)]
@@ -99,6 +100,17 @@ pub struct NotificationClient {
 
 #[matrix_sdk_ffi_macros::export]
 impl NotificationClient {
+    /// Fetches a room by its ID using the in-memory state store backed client.
+    ///
+    /// Useful to retrieve room information after running the limited
+    /// notification client sliding sync loop.
+    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)
+    }
+
     /// See also documentation of
     /// `MatrixNotificationClient::get_notification`.
     pub async fn get_notification(

crates/matrix-sdk-ui/src/notification_client.rs

@@ -125,6 +125,13 @@ impl NotificationClient {
         })
     }
 
+    /// Fetches a room by its ID using the in-memory state store backed client.
+    /// Useful to retrieve room information after running the limited
+    /// notification client sliding sync loop.
+    pub fn get_room(&self, room_id: &RoomId) -> Option<Room> {
+        self.client.get_room(room_id)
+    }
+
     /// Fetches the content of a notification.
     ///
     /// This will first try to get the notification using a short-lived sliding