chore(room_preview): Add knocking action to the RoomPreviewActions too

Author: jmartinesp

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

@@ -2,7 +2,6 @@ use std::{
     collections::HashMap,
     fmt::Debug,
     mem::ManuallyDrop,
-    ops::Deref,
     path::Path,
     sync::{Arc, RwLock},
 };
@@ -1028,7 +1027,7 @@ impl Client {
         &self,
         room_id: String,
         via_servers: Vec<String>,
-    ) -> Result<RoomPreview, ClientError> {
+    ) -> Result<Arc<RoomPreview>, ClientError> {
         let room_id = RoomId::parse(&room_id).context("room_id is not a valid room id")?;
 
         let via_servers = via_servers
@@ -1042,16 +1041,15 @@ impl Client {
         let room_id: &RoomId = &room_id;
 
         let sdk_room_preview = self.inner.get_room_preview(room_id.into(), via_servers).await?;
-        let client = (*self.inner.deref()).clone();
 
-        RoomPreview::try_from_sdk(sdk_room_preview, client)
+        Ok(Arc::new(RoomPreview::from_sdk(sdk_room_preview)))
     }
 
     /// Given a room alias, get the preview of a room, to interact with it.
     pub async fn get_room_preview_from_room_alias(
         &self,
         room_alias: String,
-    ) -> Result<RoomPreview, ClientError> {
+    ) -> Result<Arc<RoomPreview>, ClientError> {
         let room_alias =
             RoomAliasId::parse(&room_alias).context("room_alias is not a valid room alias")?;
 
@@ -1060,9 +1058,8 @@ impl Client {
         let room_alias: &RoomAliasId = &room_alias;
 
         let sdk_room_preview = self.inner.get_room_preview(room_alias.into(), Vec::new()).await?;
-        let client = (*self.inner.deref()).clone();
 
-        RoomPreview::try_from_sdk(sdk_room_preview, client)
+        Ok(Arc::new(RoomPreview::from_sdk(sdk_room_preview)))
     }
 
     /// Waits until an at least partially synced room is received, and returns
@@ -1807,7 +1804,7 @@ impl From<OidcPrompt> for SdkOidcPrompt {
 }
 
 /// The rule used for users wishing to join this room.
-#[derive(uniffi::Enum)]
+#[derive(Debug, Clone, uniffi::Enum)]
 pub enum JoinRule {
     /// Anyone can join the room without any prior action.
     Public,
@@ -1836,7 +1833,7 @@ pub enum JoinRule {
 }
 
 /// An allow rule which defines a condition that allows joining a room.
-#[derive(uniffi::Enum)]
+#[derive(Debug, Clone, uniffi::Enum)]
 pub enum AllowRule {
     /// Only a member of the `room_id` Room can join the one this rule is used
     /// in.

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

@@ -2,13 +2,13 @@ use std::{collections::HashMap, fmt, fmt::Display};
 
 use matrix_sdk::{
     encryption::CryptoStoreError, event_cache::EventCacheError, oidc::OidcError, reqwest,
-    room::edit::EditError, send_queue::RoomSendQueueError, HttpError, IdParseError,
-    NotificationSettingsError as SdkNotificationSettingsError,
+    room::edit::EditError, room_preview::WrongRoomPreviewState, send_queue::RoomSendQueueError,
+    HttpError, IdParseError, NotificationSettingsError as SdkNotificationSettingsError,
     QueueWedgeError as SdkQueueWedgeError, StoreError,
 };
 use matrix_sdk_ui::{encryption_sync_service, notification_client, sync_service, timeline};
 use uniffi::UnexpectedUniFFICallbackError;
-use matrix_sdk::room_preview::RoomPreviewError;
+
 use crate::room_list::RoomListError;
 
 #[derive(Debug, thiserror::Error)]
@@ -155,8 +155,8 @@ impl From<RoomSendQueueError> for ClientError {
     }
 }
 
-impl From<RoomPreviewError> for ClientError {
-    fn from(e: RoomSendQueueError) -> Self {
+impl From<WrongRoomPreviewState> for ClientError {
+    fn from(e: WrongRoomPreviewState) -> Self {
         Self::new(e)
     }
 }

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

@@ -45,7 +45,7 @@ use crate::{
     TaskHandle,
 };
 
-#[derive(Debug, uniffi::Enum)]
+#[derive(Debug, Clone, uniffi::Enum)]
 pub enum Membership {
     Invited,
     Joined,

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

@@ -16,9 +16,7 @@ use matrix_sdk_ui::{
     timeline::default_event_filter,
     unable_to_decrypt_hook::UtdHookManager,
 };
-use ruma::{
-    IdParseError, OwnedRoomOrAliasId, OwnedServerName, RoomAliasId, RoomOrAliasId, ServerName,
-};
+use ruma::{OwnedRoomOrAliasId, OwnedServerName, ServerName};
 use tokio::sync::RwLock;
 
 use crate::{
@@ -595,10 +593,10 @@ impl RoomListItem {
         Ok(Arc::new(Room::new(self.inner.inner_room().clone())))
     }
 
-    /// Builds a `RoomPreview` from a room list item. This is intended for rooms
-    /// with [`Membership::Invite`] or [`Membership::Knocked`],
+    /// Builds a `RoomPreview` from a room list item. This is intended for
+    /// invited or knocked rooms.
     ///
-    /// An error will be returned if the room is a state other than invited
+    /// An error will be returned if the room is in a state other than invited
     /// or knocked.
     async fn preview_room(&self, via: Vec<String>) -> Result<Arc<RoomPreview>, ClientError> {
         let membership = self.membership();
@@ -624,7 +622,7 @@ impl RoomListItem {
         };
 
         let room_preview = client.get_room_preview(&room_or_alias_id, server_names).await?;
-        Ok(Arc::new(RoomPreview::try_from_sdk(room_preview, client)))
+        Ok(Arc::new(RoomPreview::from_sdk(room_preview)))
     }
 
     /// Build a full `Room` FFI object, filling its associated timeline.

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

@@ -1,81 +1,48 @@
-use matrix_sdk::{
-    room_preview::{
-        JoinRoomPreviewAction as SdkJoinRoomPreviewAction, LeaveRoomPreviewAction as SdkLeaveRoomPreviewAction, RoomPreview as SdkRoomPreview,
-        RoomPreviewActions,
-    },
-    Client, RoomState,
-};
+use std::sync::Arc;
+
+use matrix_sdk::room_preview::RoomPreview as SdkRoomPreview;
 use ruma::space::SpaceRoomJoinRule;
 
 use crate::{client::JoinRule, error::ClientError, room::Membership};
 
-#[derive(uniffi::Record)]
-pub struct RoomPreview {
-    pub info: RoomPreviewInfo,
-    pub room_preview_actions: RoomPreviewActions,
-    pub(crate) sdk_info: matrix_sdk::room_preview::RoomPreview,
-}
-
-#[derive(uniffi::Enum)]
-pub enum RoomPreviewAction {
-    Invited { join: JoinRoomPreviewAction, leave: LeaveRoomPreviewAction },
-    Knocked { leave: LeaveRoomPreviewAction },
-}
-
+/// A room preview for a room. It's intended to be used to represent rooms that
+/// aren't joined yet.
 #[derive(uniffi::Object)]
-pub struct JoinRoomPreviewAction {
-    inner: SdkJoinRoomPreviewAction,
+pub struct RoomPreview {
+    inner: Arc<SdkRoomPreview>,
 }
 
 #[matrix_sdk_ffi_macros::export]
-impl JoinRoomPreviewAction {
-    async fn run(&self) {
-        self.inner.run().unwrap()
+impl RoomPreview {
+    /// Returns the room info the preview contains.
+    pub fn info(&self) -> RoomPreviewInfo {
+        let info = &self.inner;
+        RoomPreviewInfo {
+            room_id: info.room_id.to_string(),
+            canonical_alias: info.canonical_alias.as_ref().map(|alias| alias.to_string()),
+            name: info.name.clone(),
+            topic: info.topic.clone(),
+            avatar_url: info.avatar_url.as_ref().map(|url| url.to_string()),
+            num_joined_members: info.num_joined_members,
+            room_type: info.room_type.as_ref().map(|room_type| room_type.to_string()),
+            is_history_world_readable: info.is_world_readable,
+            membership: info.state.map(|state| state.into()),
+            join_rule: info.join_rule.clone().into(),
+        }
     }
-}
 
-impl From<matrix_sdk::room_preview::RoomPreviewActions> for RoomPreviewAction {
-    fn from(actions: RoomPreviewActions) -> Self {
-        match actions {
-            RoomPreviewActions::Invited { join, leave } => Self::Invited { join, leave },
-            RoomPreviewActions::Knocked { leave } => Self::Knocked { leave },
-        }
+    /// Leave the room if the room preview state is either joined, invited or
+    /// knocked.
+    ///
+    /// Will return an error otherwise.
+    pub async fn leave(&self) -> Result<(), ClientError> {
+        self.inner.leave().await.map_err(Into::into)
     }
 }
 
-struct
-
 impl RoomPreview {
-    pub(crate) fn try_from_sdk(info: SdkRoomPreview, client: Client) -> Result<Self, ClientError> {
-        let info = RoomPreviewInfo {
-            room_id: info.room_id.to_string(),
-            canonical_alias: info.canonical_alias.map(|alias| alias.to_string()),
-            name: info.name,
-            topic: info.topic,
-            avatar_url: info.avatar_url.map(|url| url.to_string()),
-            num_joined_members: info.num_joined_members,
-            room_type: info.room_type.map(|room_type| room_type.to_string()),
-            is_history_world_readable: info.is_world_readable,
-            membership: info.state.map(|state| state.into()).unwrap_or_else(|| Membership::Left),
-            join_rule: info.join_rule.into(),
-        };
-
-        let room_preview_actions = match info.membership {
-            Membership::Invited => RoomPreviewActions::Invited {
-                join: JoinRoomPreviewAction::new(client.clone()),
-                leave: LeaveRoomPreviewAction::new(client.clone()),
-            },
-            Membership::Knocked => {
-                RoomPreviewActions::Knocked { leave: LeaveRoomPreviewAction::new(client.clone()) }
-            }
-            _ => {
-                return Err(ClientError::new(format!(
-                    "The room preview had membership {:?} instead of Invited or Knocked.",
-                    info.membership
-                )))
-            }
-        };
-        Ok(Self { info, room_preview_actions })
+    pub(crate) fn from_sdk(room_preview: SdkRoomPreview) -> Self {
+        Self { inner: Arc::new(room_preview) }
     }
 }
 
@@ -98,23 +65,28 @@ pub struct RoomPreviewInfo {
     pub room_type: Option<String>,
     /// Is the history world-readable for this room?
     pub is_history_world_readable: bool,
-    /// Is the room joined by the current user?
-    pub membership: Membership,
-    /// is the join rule public for this room?
+    /// The membership state for the current user, if known.
+    pub membership: Option<Membership>,
+    /// The join rule for this room (private, public, knock, etc.).
     pub join_rule: JoinRule,
 }
 
 impl From<SpaceRoomJoinRule> for JoinRule {
     fn from(join_rule: SpaceRoomJoinRule) -> Self {
         match join_rule {
-            SpaceRoomJoinRule::Public => JoinRule::Public,
-            SpaceRoomJoinRule::Private => JoinRule::Private,
             SpaceRoomJoinRule::Invite => JoinRule::Invite,
             SpaceRoomJoinRule::Knock => JoinRule::Knock,
-            SpaceRoomJoinRule::KnockRestricted => JoinRule::KnockRestricted { rules: Vec::new() },
+            SpaceRoomJoinRule::Private => JoinRule::Private,
             SpaceRoomJoinRule::Restricted => JoinRule::Restricted { rules: Vec::new() },
-            // For the `_Custom` case, assume it's private
-            _ => JoinRule::Private,
+            SpaceRoomJoinRule::KnockRestricted => JoinRule::KnockRestricted { rules: Vec::new() },
+            SpaceRoomJoinRule::Public => JoinRule::Public,
+            _ => {
+                // Since we have no way to get the _Custom contents, assume it's private.
+                // Warning! If new join rules are introduced we may be mapping wrong values
+                // here, but there's no way to match
+                // `SpaceRoomJoinRule::_Custom(_)` and have an exhaustive match.
+                JoinRule::Private
+            }
         }
     }
 }

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

@@ -186,8 +186,6 @@ impl RoomSummary {
 /// Enum keeping track in which state the room is, e.g. if our own user is
 /// joined, RoomState::Invited, or has left the room.
 #[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
-#[cfg(feature = "uniffi")]
-#[derive(uniffi::Enum)]
 pub enum RoomState {
     /// The room is in a joined state.
     Joined,

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

@@ -19,7 +19,7 @@ use std::{collections::BTreeMap, fmt};
 use matrix_sdk_common::{debug::DebugRawEvent, deserialized_responses::SyncTimelineEvent};
 use ruma::{
     api::client::sync::sync_events::{
-        v3::{InvitedRoom as InvitedRoomUpdate, KnockedRoom},
+        v3::{InvitedRoom as InvitedRoomUpdate, KnockedRoom as KnockedRoomUpdate},
         UnreadNotificationsCount as RumaUnreadNotificationsCount,
     },
     events::{
@@ -78,7 +78,7 @@ pub struct RoomUpdates {
     /// The rooms that the user has been invited to.
     pub invite: BTreeMap<OwnedRoomId, InvitedRoomUpdate>,
     /// The rooms that the user has knocked on.
-    pub knocked: BTreeMap<OwnedRoomId, KnockedRoom>,
+    pub knocked: BTreeMap<OwnedRoomId, KnockedRoomUpdate>,
 }
 
 impl RoomUpdates {
@@ -254,7 +254,7 @@ impl<'a> fmt::Debug for DebugInvitedRoomUpdates<'a> {
     }
 }
 
-struct DebugKnockedRoomUpdates<'a>(&'a BTreeMap<OwnedRoomId, KnockedRoom>);
+struct DebugKnockedRoomUpdates<'a>(&'a BTreeMap<OwnedRoomId, KnockedRoomUpdate>);
 
 #[cfg(not(tarpaulin_include))]
 impl<'a> fmt::Debug for DebugKnockedRoomUpdates<'a> {

crates/matrix-sdk/src/client/mod.rs

@@ -54,7 +54,7 @@ use ruma::{
             },
             filter::{create_filter::v3::Request as FilterUploadRequest, FilterDefinition},
             knock::knock_room,
-            membership::{join_room_by_id, join_room_by_id_or_alias},
+            membership::{join_room_by_id, join_room_by_id_or_alias, leave_room},
             room::create_room,
             session::login::v3::DiscoveryInfo,
             sync::sync_events,
@@ -1208,6 +1208,13 @@ impl Client {
         Ok(Room::new(self.clone(), base_room))
     }
 
+    /// Leave a room given its `RoomId`.
+    pub async fn leave_room(&self, room_id: &RoomId) -> Result<()> {
+        let request = leave_room::v3::Request::new(room_id.to_owned());
+        self.send(request, None).await?;
+        self.base_client().room_left(room_id).await.map_err(Into::into)
+    }
+
     /// Search the homeserver's directory of public rooms.
     ///
     /// Sends a request to "_matrix/client/r0/publicRooms", returns

crates/matrix-sdk/src/error.rs

@@ -45,7 +45,9 @@ use serde_json::Error as JsonError;
 use thiserror::Error;
 use url::ParseError as UrlParseError;
 
-use crate::{event_cache::EventCacheError, store_locks::LockStoreError};
+use crate::{
+    event_cache::EventCacheError, room_preview::WrongRoomPreviewState, store_locks::LockStoreError,
+};
 
 /// Result type of the matrix-sdk.
 pub type Result<T, E = Error> = std::result::Result<T, E>;
@@ -348,6 +350,12 @@ pub enum Error {
     #[error("wrong room state: {0}")]
     WrongRoomState(WrongRoomState),
 
+    /// Attempted to call a method on a room preview that requires the user to
+    /// have a specific membership state in the room, but the membership
+    /// state is different or none.
+    #[error("wrong room state: {0}")]
+    WrongRoomPreviewState(WrongRoomPreviewState),
+
     /// Session callbacks have been set multiple times.
     #[error("session callbacks have been set multiple times")]
     MultipleSessionCallbacks,

crates/matrix-sdk/src/room/mod.rs

@@ -47,7 +47,7 @@ use ruma::{
         membership::{
             ban_user, forget_room, get_member_events,
             invite_user::{self, v3::InvitationRecipient},
-            join_room_by_id, kick_user, leave_room, unban_user, Invite3pid,
+            kick_user, leave_room, unban_user, Invite3pid,
         },
         message::send_message_event,
         read_marker::set_read_marker,