feat(labs): add create room ability to multiverse

Signed-off-by: Skye Elliot <[email protected]>

Author: kaylendog

crates/matrix-sdk-base/src/response_processors/state_events.rs

@@ -25,7 +25,7 @@ use ruma::{
 use serde::Deserialize;
 use tracing::warn;
 
-use super::{e2ee, Context};
+use super::{Context, e2ee};
 use crate::store::BaseStateStore;
 
 /// Collect [`AnySyncStateEvent`].

crates/matrix-sdk-base/src/room/room_info.rs

@@ -619,10 +619,18 @@ impl RoomInfo {
     pub fn encryption_state(&self) -> EncryptionState {
         if !self.encryption_state_synced {
             EncryptionState::Unknown
-        } else if self.base_info.encryption.is_some() {
-            EncryptionState::Encrypted
         } else {
-            EncryptionState::NotEncrypted
+            self.base_info
+                .encryption
+                .as_ref()
+                .map(|state| {
+                    if state.encrypt_state_events {
+                        EncryptionState::StateEncrypted
+                    } else {
+                        EncryptionState::Encrypted
+                    }
+                })
+                .unwrap_or(EncryptionState::NotEncrypted)
         }
     }
 

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

@@ -408,15 +408,7 @@ impl<'a> SendStateEventRaw<'a> {
 
     /// Returns `true` if the inner event should be encrypted.
     async fn should_encrypt(room: &Room, event_type: &str) -> bool {
-        let olm = room.client.olm_machine().await;
-        let olm = olm.as_ref().expect("Olm machine was not started.");
-
-        // Lookup room settings and check encryptiong state.
-        let Ok(Some(settings)) = olm.room_settings(room.room_id()).await else {
-            trace!("Sending plaintext event as the room is NOT encrypted.");
-            return false;
-        };
-        if !settings.encrypt_state_events {
+        if !room.encryption_state().is_state_encrypted() {
             trace!("Sending plaintext event as the room does NOT support encrypted state events.");
             return false;
         }

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

@@ -1959,6 +1959,48 @@ impl Room {
         Ok(())
     }
 
+    /// Enable End-to-end encryption in this room, with experimental encrypted state events.
+    #[instrument(skip_all)]
+    pub async fn enable_encryption_with_state(&self) -> Result<()> {
+        use ruma::{
+            events::room::encryption::RoomEncryptionEventContent, EventEncryptionAlgorithm,
+        };
+        const SYNC_WAIT_TIME: Duration = Duration::from_secs(3);
+
+        if !self.latest_encryption_state().await?.is_encrypted() {
+            let content =
+                RoomEncryptionEventContent::new(EventEncryptionAlgorithm::MegolmV1AesSha2)
+                    .with_encrypted_state();
+            self.send_state_event(content).await?;
+
+            // TODO do we want to return an error here if we time out? This
+            // could be quite useful if someone wants to enable encryption and
+            // send a message right after it's enabled.
+            _ = timeout(self.client.inner.sync_beat.listen(), SYNC_WAIT_TIME).await;
+
+            // If after waiting for a sync, we don't have the encryption state we expect,
+            // assume the local encryption state is incorrect; this will cause
+            // the SDK to re-request it later for confirmation, instead of
+            // assuming it's sync'd and correct (and not encrypted).
+            let _sync_lock = self.client.base_client().sync_lock().lock().await;
+            if !self.inner.encryption_state().is_state_encrypted() {
+                debug!("still not marked as encrypted, marking encryption state as missing");
+
+                let mut room_info = self.clone_info();
+                room_info.mark_encryption_state_missing();
+                let mut changes = StateChanges::default();
+                changes.add_room(room_info.clone());
+
+                self.client.state_store().save_changes(&changes).await?;
+                self.set_room_info(room_info, RoomInfoNotableUpdateReasons::empty());
+            } else {
+                debug!("room successfully marked as encrypted");
+            }
+        }
+
+        Ok(())
+    }
+
     /// Share a room key with users in the given room.
     ///
     /// This will create Olm sessions with all the users/device pairs in the

labs/multiverse/src/widgets/room_view/input.rs

@@ -14,11 +14,22 @@ struct Cli {
 
 #[derive(Debug, Subcommand)]
 pub enum Command {
-    Invite { user_id: String },
+    Create {
+        name: String,
+        #[clap(long)]
+        encrypted: bool,
+        #[clap(long)]
+        state_encrypted: bool,
+    },
+    Invite {
+        user_id: String,
+    },
     Leave,
     Subscribe,
     Unsubscribe,
-    Rename { to: String },
+    Rename {
+        to: String,
+    },
 }
 
 pub enum MessageOrCommand {

labs/multiverse/src/widgets/room_view/mod.rs

@@ -10,7 +10,11 @@ use matrix_sdk::{
     locks::Mutex,
     ruma::{
         OwnedEventId, OwnedRoomId, RoomId, UserId,
-        api::client::receipt::create_receipt::v3::ReceiptType,
+        api::client::{
+            receipt::create_receipt::v3::ReceiptType,
+            room::create_room::v3::Request as CreateRoomRequest,
+        },
+        assign,
         events::room::message::RoomMessageEventContent,
     },
     store::ThreadStatus,
@@ -447,6 +451,27 @@ impl RoomView {
         }
     }
 
+    async fn create_room(&mut self, name: String, encrypted: bool, state_encrypted: bool) {
+        // Create a room in the internal store
+        let room = self
+            .client
+            .create_room(assign!(CreateRoomRequest::new(), {
+                name: Some(name),
+                invite: vec![],
+                is_direct: false,
+            }))
+            .await
+            .unwrap();
+
+        // Enable encryption
+        if encrypted && !state_encrypted {
+            room.enable_encryption().await.unwrap();
+        }
+        if state_encrypted {
+            room.enable_encryption_with_state().await.unwrap();
+        }
+    }
+
     async fn invite_member(&mut self, user_id: &str) {
         self.call_with_room(async move |room, status_handle| {
             let user_id = match UserId::parse_with_server_name(
@@ -565,6 +590,9 @@ impl RoomView {
 
     async fn handle_command(&mut self, command: input::Command) {
         match command {
+            input::Command::Create { name, encrypted, state_encrypted } => {
+                self.create_room(name, encrypted, state_encrypted).await
+            }
             input::Command::Invite { user_id } => self.invite_member(&user_id).await,
             input::Command::Leave => self.leave_room().await,
             input::Command::Subscribe => self.subscribe_thread().await,