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

Author: jmartinesp

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

@@ -1807,7 +1807,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 +1836,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::RoomStateActionError, 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<RoomStateActionError> for ClientError {
+    fn from(e: RoomStateActionError) -> 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::{
@@ -600,7 +598,7 @@ impl RoomListItem {
     ///
     /// An error will be returned if the room is a state other than invited
     /// or knocked.
-    async fn preview_room(&self, via: Vec<String>) -> Result<Arc<RoomPreview>, ClientError> {
+    async fn preview_room(&self, via: Vec<String>) -> Result<RoomPreview, ClientError> {
         let membership = self.membership();
         if !matches!(membership, Membership::Invited | Membership::Knocked) {
             return Err(RoomListError::IncorrectRoomMembership {
@@ -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)))
+        RoomPreview::try_from_sdk(room_preview, client)
     }
 
     /// Build a full `Room` FFI object, filling its associated timeline.

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

@@ -1,80 +1,71 @@
+use std::sync::Arc;
+
 use matrix_sdk::{
-    room_preview::{
-        JoinRoomPreviewAction as SdkJoinRoomPreviewAction, LeaveRoomPreviewAction as SdkLeaveRoomPreviewAction, RoomPreview as SdkRoomPreview,
-        RoomPreviewActions,
-    },
-    Client, RoomState,
+    room_preview::{RoomPreview as SdkRoomPreview, RoomPreviewActions as SdkRoomPreviewActions},
+    Client,
 };
-use ruma::space::SpaceRoomJoinRule;
+use ruma::{space::SpaceRoomJoinRule, ServerName};
 
 use crate::{client::JoinRule, error::ClientError, room::Membership};
 
+/// A room preview for a room. It's intended to be used to represent rooms that
+/// aren't joined yet.
 #[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 },
+    pub room_preview_actions: Arc<RoomPreviewActions>,
 }
 
+/// Actions to perform in a room preview, such as join/leave.
 #[derive(uniffi::Object)]
-pub struct JoinRoomPreviewAction {
-    inner: SdkJoinRoomPreviewAction,
+pub struct RoomPreviewActions {
+    inner: SdkRoomPreviewActions,
 }
 
 #[matrix_sdk_ffi_macros::export]
-impl JoinRoomPreviewAction {
-    async fn run(&self) {
-        self.inner.run().unwrap()
+impl RoomPreviewActions {
+    /// Join the room.
+    async fn join(&self) -> Result<(), ClientError> {
+        Ok(self.inner.join.run().await?)
     }
-}
 
-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.
+    async fn leave(&self) -> Result<(), ClientError> {
+        Ok(self.inner.leave.run().await?)
     }
-}
 
-struct
+    /// Knock on the room.
+    async fn knock(&self, reason: Option<String>, via: Vec<String>) -> Result<(), ClientError> {
+        let via = via.iter().map(ServerName::parse).collect::<Result<Vec<_>, _>>()?;
+        Ok(self.inner.knock.run(reason, via).await?)
+    }
+}
 
 impl RoomPreview {
-    pub(crate) fn try_from_sdk(info: SdkRoomPreview, client: Client) -> Result<Self, ClientError> {
+    pub(crate) fn try_from_sdk(
+        room_preview: SdkRoomPreview,
+        client: Client,
+    ) -> Result<Self, ClientError> {
+        let room_preview_actions = Arc::new(RoomPreviewActions {
+            inner: SdkRoomPreviewActions::new(client, room_preview.clone()),
+        });
+
         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(),
+            room_id: room_preview.room_id.to_string(),
+            canonical_alias: room_preview.canonical_alias.map(|alias| alias.to_string()),
+            name: room_preview.name,
+            topic: room_preview.topic,
+            avatar_url: room_preview.avatar_url.map(|url| url.to_string()),
+            num_joined_members: room_preview.num_joined_members,
+            room_type: room_preview.room_type.map(|room_type| room_type.to_string()),
+            is_history_world_readable: room_preview.is_world_readable,
+            membership: room_preview
+                .state
+                .map(|state| state.into())
+                .unwrap_or_else(|| Membership::Left),
+            join_rule: room_preview.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 })
     }
 }

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/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,