feat(room): add RequestToJoinRoom subscriptions

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

@@ -1,7 +1,7 @@
 use std::{collections::HashMap, pin::pin, sync::Arc};
 
 use anyhow::{Context, Result};
-use futures_util::StreamExt;
+use futures_util::{pin_mut, StreamExt};
 use matrix_sdk::{
     crypto::LocalTrust,
     event_cache::paginator::PaginatorError,
@@ -840,6 +840,108 @@ impl Room {
 
         Ok(())
     }
+
+    /// Subscribes to requests to join this room, using a `listener` to be
+    /// notified of the changes.
+    ///
+    /// The current requests to join the room will be emitted immediately
+    /// when subscribing, along with a [`TaskHandle`] to cancel the
+    /// subscription.
+    pub async fn subscribe_to_requests_to_join(
+        self: Arc<Self>,
+        listener: Box<dyn RequestsToJoinListener>,
+    ) -> Result<Arc<TaskHandle>, ClientError> {
+        let stream = self.inner.subscribe_to_requests_to_join().await?;
+
+        let handle = Arc::new(TaskHandle::new(RUNTIME.spawn(async move {
+            pin_mut!(stream);
+            while let Some(requests) = stream.next().await {
+                listener.call(requests.into_iter().map(Into::into).collect());
+            }
+        })));
+
+        Ok(handle)
+    }
+}
+
+impl From<matrix_sdk::room::request_to_join::RequestToJoinRoom> for RequestToJoin {
+    fn from(request: matrix_sdk::room::request_to_join::RequestToJoinRoom) -> Self {
+        Self {
+            event_id: request.event_id.to_string(),
+            user_id: request.member_info.user_id.to_string(),
+            room_id: request.room_id().to_string(),
+            display_name: request.member_info.display_name.clone(),
+            avatar_url: request.member_info.avatar_url.as_ref().map(|url| url.to_string()),
+            reason: request.member_info.reason.clone(),
+            timestamp: request.timestamp.map(|ts| ts.into()),
+            is_seen: request.is_seen,
+            actions: Arc::new(RequestToJoinActions { inner: request }),
+        }
+    }
+}
+
+/// A listener for receiving new requests to a join a room.
+#[matrix_sdk_ffi_macros::export(callback_interface)]
+pub trait RequestsToJoinListener: Send + Sync {
+    fn call(&self, requests_to_join: Vec<RequestToJoin>);
+}
+
+/// An FFI representation of a request to join a room.
+#[derive(Debug, Clone, uniffi::Record)]
+pub struct RequestToJoin {
+    /// The event id of the event that contains the `knock` membership change.
+    pub event_id: String,
+    /// The user id of the user who's requesting to join the room.
+    pub user_id: String,
+    /// The room id of the room whose access was requested.
+    pub room_id: String,
+    /// The optional display name of the user who's requesting to join the room.
+    pub display_name: Option<String>,
+    /// The optional avatar url of the user who's requesting to join the room.
+    pub avatar_url: Option<String>,
+    /// An optional reason why the user wants join the room.
+    pub reason: Option<String>,
+    /// The timestamp when this request was created.
+    pub timestamp: Option<u64>,
+    /// Whether the request to join has been marked as `seen` so it can be
+    /// filtered by the client.
+    pub is_seen: bool,
+    /// A set of actions to perform for this request to join.
+    pub actions: Arc<RequestToJoinActions>,
+}
+
+/// A set of actions to perform for a request to join.
+#[derive(Debug, Clone, uniffi::Object)]
+pub struct RequestToJoinActions {
+    inner: matrix_sdk::room::request_to_join::RequestToJoinRoom,
+}
+
+#[matrix_sdk_ffi_macros::export]
+impl RequestToJoinActions {
+    /// Accepts the request to join by inviting the user to the room.
+    pub async fn accept(&self) -> Result<(), ClientError> {
+        self.inner.accept().await.map_err(Into::into)
+    }
+
+    /// Declines the request to join by kicking the user from the room with an
+    /// optional reason.
+    pub async fn decline(&self, reason: Option<String>) -> Result<(), ClientError> {
+        self.inner.decline(reason.as_deref()).await.map_err(Into::into)
+    }
+
+    /// Declines the request to join by banning the user from the room with an
+    /// optional reason.
+    pub async fn decline_and_ban(&self, reason: Option<String>) -> Result<(), ClientError> {
+        self.inner.decline_and_ban(reason.as_deref()).await.map_err(Into::into)
+    }
+
+    /// Marks the request as 'seen'.
+    ///
+    /// **IMPORTANT**: this won't update the current reference to this request,
+    /// a new one with the updated value should be emitted instead.
+    pub async fn mark_as_seen(&self) -> Result<(), ClientError> {
+        self.inner.clone().mark_as_seen().await.map_err(Into::into)
+    }
 }
 
 /// Generates a `matrix.to` permalink to the given room alias.

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

@@ -30,7 +30,7 @@ use ruma::{
         StateEventContent, StaticStateEventContent, StrippedStateEvent, SyncStateEvent,
     },
     serde::Raw,
-    EventId, MilliSecondsSinceUnixEpoch, OwnedEventId, OwnedRoomId, OwnedUserId, UserId,
+    EventId, MilliSecondsSinceUnixEpoch, OwnedEventId, OwnedRoomId, OwnedUserId, UInt, UserId,
 };
 use serde::Serialize;
 use unicode_normalization::UnicodeNormalization;
@@ -476,6 +476,23 @@ impl MemberEvent {
                 .unwrap_or_else(|| self.user_id().localpart()),
         )
     }
+
+    /// The optional reason why the membership changed.
+    pub fn reason(&self) -> Option<&str> {
+        match self {
+            MemberEvent::Sync(SyncStateEvent::Original(c)) => c.content.reason.as_deref(),
+            MemberEvent::Stripped(e) => e.content.reason.as_deref(),
+            _ => None,
+        }
+    }
+
+    /// The optional timestamp for this member event.
+    pub fn timestamp(&self) -> Option<UInt> {
+        match self {
+            MemberEvent::Sync(SyncStateEvent::Original(c)) => Some(c.origin_server_ts.0),
+            _ => None,
+        }
+    }
 }
 
 impl SyncOrStrippedState<RoomPowerLevelsEventContent> {

crates/matrix-sdk-base/src/rooms/normal.rs

@@ -145,6 +145,9 @@ pub struct Room {
     /// to disk but held in memory.
     #[cfg(all(feature = "e2e-encryption", feature = "experimental-sliding-sync"))]
     pub latest_encrypted_events: Arc<SyncRwLock<RingBuffer<Raw<AnySyncTimelineEvent>>>>,
+
+    /// The event ids for seen request to join room events.
+    pub seen_requests_to_join_ids: SharedObservable<Option<HashSet<OwnedEventId>>>,
 }
 
 /// The room summary containing member counts and members that should be used to
@@ -255,6 +258,7 @@ impl Room {
                 Self::MAX_ENCRYPTED_EVENTS,
             ))),
             room_info_notable_update_sender,
+            seen_requests_to_join_ids: SharedObservable::new(None),
         }
     }
 

crates/matrix-sdk-base/src/store/memory_store.rs

@@ -13,7 +13,7 @@
 // limitations under the License.
 
 use std::{
-    collections::{BTreeMap, BTreeSet, HashMap},
+    collections::{BTreeMap, BTreeSet, HashMap, HashSet},
     sync::RwLock as StdRwLock,
 };
 
@@ -91,6 +91,7 @@ pub struct MemoryStore {
     custom: StdRwLock<HashMap<Vec<u8>, Vec<u8>>>,
     send_queue_events: StdRwLock<BTreeMap<OwnedRoomId, Vec<QueuedRequest>>>,
     dependent_send_queue_events: StdRwLock<BTreeMap<OwnedRoomId, Vec<DependentQueuedRequest>>>,
+    seen_requests_to_join: StdRwLock<BTreeMap<OwnedRoomId, HashSet<OwnedEventId>>>,
 }
 
 impl MemoryStore {
@@ -186,6 +187,13 @@ impl StateStore for MemoryStore {
                 .get(room_id)
                 .cloned()
                 .map(StateStoreDataValue::ComposerDraft),
+            StateStoreDataKey::SeenRequestsToJoin(room_id) => self
+                .seen_requests_to_join
+                .read()
+                .unwrap()
+                .get(room_id)
+                .cloned()
+                .map(StateStoreDataValue::SeenRequestsToJoin),
         })
     }
 
@@ -239,6 +247,14 @@ impl StateStore for MemoryStore {
                         .expect("Session data not containing server capabilities"),
                 );
             }
+            StateStoreDataKey::SeenRequestsToJoin(room_id) => {
+                self.seen_requests_to_join.write().unwrap().insert(
+                    room_id.to_owned(),
+                    value
+                        .into_seen_join_requests()
+                        .expect("Session data not a set of ignored join requests"),
+                );
+            }
         }
 
         Ok(())
@@ -265,6 +281,9 @@ impl StateStore for MemoryStore {
             StateStoreDataKey::ComposerDraft(room_id) => {
                 self.composer_drafts.write().unwrap().remove(room_id);
             }
+            StateStoreDataKey::SeenRequestsToJoin(room_id) => {
+                self.seen_requests_to_join.write().unwrap().remove(room_id);
+            }
         }
         Ok(())
     }

crates/matrix-sdk-base/src/store/traits.rs

@@ -14,7 +14,7 @@
 
 use std::{
     borrow::Borrow,
-    collections::{BTreeMap, BTreeSet, HashMap},
+    collections::{BTreeMap, BTreeSet, HashMap, HashSet},
     fmt,
     sync::Arc,
 };
@@ -1022,6 +1022,9 @@ pub enum StateStoreDataValue {
     ///
     /// [`ComposerDraft`]: Self::ComposerDraft
     ComposerDraft(ComposerDraft),
+
+    /// A list of requests to join marked as seen in a room.
+    SeenRequestsToJoin(HashSet<OwnedEventId>),
 }
 
 /// Current draft of the composer for the room.
@@ -1088,6 +1091,11 @@ impl StateStoreDataValue {
     pub fn into_server_capabilities(self) -> Option<ServerCapabilities> {
         as_variant!(self, Self::ServerCapabilities)
     }
+
+    /// Get this value if it is the data for the ignored join requests.
+    pub fn into_seen_join_requests(self) -> Option<HashSet<OwnedEventId>> {
+        as_variant!(self, Self::SeenRequestsToJoin)
+    }
 }
 
 /// A key for key-value data.
@@ -1117,6 +1125,9 @@ pub enum StateStoreDataKey<'a> {
     ///
     /// [`ComposerDraft`]: Self::ComposerDraft
     ComposerDraft(&'a RoomId),
+
+    /// A list of requests to join in a room marked as seen.
+    SeenRequestsToJoin(&'a RoomId),
 }
 
 impl StateStoreDataKey<'_> {
@@ -1142,6 +1153,10 @@ impl StateStoreDataKey<'_> {
     /// Key prefix to use for the [`ComposerDraft`][Self::ComposerDraft]
     /// variant.
     pub const COMPOSER_DRAFT: &'static str = "composer_draft";
+
+    /// Key prefix to use for the
+    /// [`SeenRequestsToJoin`][Self::SeenRequestsToJoin] variant.
+    pub const SEEN_REQUESTS_TO_JOIN: &'static str = "seen_requests_to_join";
 }
 
 #[cfg(test)]

crates/matrix-sdk-indexeddb/src/state_store/mod.rs

@@ -419,6 +419,9 @@ impl IndexeddbStateStore {
             StateStoreDataKey::ComposerDraft(room_id) => {
                 self.encode_key(keys::KV, (StateStoreDataKey::COMPOSER_DRAFT, room_id))
             }
+            StateStoreDataKey::SeenRequestsToJoin(room_id) => {
+                self.encode_key(keys::KV, (StateStoreDataKey::SEEN_REQUESTS_TO_JOIN, room_id))
+            }
         }
     }
 }
@@ -537,6 +540,10 @@ impl_state_store!({
                 .map(|f| self.deserialize_value::<ComposerDraft>(&f))
                 .transpose()?
                 .map(StateStoreDataValue::ComposerDraft),
+            StateStoreDataKey::SeenRequestsToJoin(_) => value
+                .map(|f| self.deserialize_value::<HashSet<OwnedEventId>>(&f))
+                .transpose()?
+                .map(StateStoreDataValue::SeenRequestsToJoin),
         };
 
         Ok(value)
@@ -574,6 +581,11 @@ impl_state_store!({
             StateStoreDataKey::ComposerDraft(_) => self.serialize_value(
                 &value.into_composer_draft().expect("Session data not a composer draft"),
             ),
+            StateStoreDataKey::SeenRequestsToJoin(_) => self.serialize_value(
+                &value
+                    .into_seen_join_requests()
+                    .expect("Session data not a set of ignored requests to join"),
+            ),
         };
 
         let tx =

crates/matrix-sdk-sqlite/src/state_store.rs

@@ -390,6 +390,9 @@ impl SqliteStateStore {
             StateStoreDataKey::ComposerDraft(room_id) => {
                 Cow::Owned(format!("{}:{room_id}", StateStoreDataKey::COMPOSER_DRAFT))
             }
+            StateStoreDataKey::SeenRequestsToJoin(room_id) => {
+                Cow::Owned(format!("{}:{room_id}", StateStoreDataKey::SEEN_REQUESTS_TO_JOIN))
+            }
         };
 
         self.encode_key(keys::KV_BLOB, &*key_s)
@@ -995,6 +998,9 @@ impl StateStore for SqliteStateStore {
                     StateStoreDataKey::ComposerDraft(_) => {
                         StateStoreDataValue::ComposerDraft(self.deserialize_value(&data)?)
                     }
+                    StateStoreDataKey::SeenRequestsToJoin(_) => {
+                        StateStoreDataValue::SeenRequestsToJoin(self.deserialize_value(&data)?)
+                    }
                 })
             })
             .transpose()
@@ -1029,6 +1035,11 @@ impl StateStore for SqliteStateStore {
             StateStoreDataKey::ComposerDraft(_) => self.serialize_value(
                 &value.into_composer_draft().expect("Session data not a composer draft"),
             )?,
+            StateStoreDataKey::SeenRequestsToJoin(_) => self.serialize_value(
+                &value
+                    .into_seen_join_requests()
+                    .expect("Session data not a set of ignored requests to join"),
+            )?,
         };
 
         self.acquire()