chore: Update dependencies

Cargo.toml

@@ -72,5 +72,6 @@ git = "https://github.com/matrix-org/matrix-rust-sdk.git"
 features = ["socks", "sso-login", "markdown", "qrcode", "experimental-timeline"]
 
 [dependencies.ruma]
-version = "0.6.2"
+git = "https://github.com/ruma/ruma"
+rev = "ca8c66c885241a7ba3805399604eda4a38979f6b"
 features = ["unstable-pre-spec", "client-api-c"]

src/session/account_settings/devices_page/device_list.rs

@@ -203,12 +203,7 @@ impl DeviceList {
 
         let handle = spawn_tokio!(async move {
             let user_id = client.user_id().unwrap();
-            let crypto_devices = client.encryption().get_user_devices(user_id).await;
-
-            let crypto_devices = match crypto_devices {
-                Ok(crypto_devices) => crypto_devices,
-                Err(error) => return Err(Error::CryptoStoreError(error)),
-            };
+            let crypto_devices = client.encryption().get_user_devices(user_id).await?;
 
             match client.devices().await {
                 Ok(mut response) => {

src/session/content/room_history/mod.rs

@@ -489,7 +489,7 @@ impl RoomHistory {
                             (
                                 // No server name needed. matrix.to URIs for mentions aren't
                                 // routable
-                                room.room_id().matrix_to_uri([]).to_string(),
+                                room.room_id().matrix_to_uri().to_string(),
                                 room.display_name(),
                             )
                         })

src/session/mod.rs

@@ -10,7 +10,7 @@ mod sidebar;
 mod user;
 pub mod verification;
 
-use std::{collections::HashSet, convert::TryFrom, fs, path::Path, time::Duration};
+use std::{collections::HashSet, convert::TryFrom, fs, path::PathBuf, time::Duration};
 
 use adw::subclass::prelude::BinImpl;
 use futures::StreamExt;
@@ -24,7 +24,7 @@ use gtk::{
 };
 use log::{debug, error, warn};
 use matrix_sdk::{
-    config::{RequestConfig, SyncSettings},
+    config::{RequestConfig, StoreConfig, SyncSettings},
     deserialized_responses::SyncResponse,
     room::Room as MatrixRoom,
     ruma::{
@@ -43,8 +43,8 @@ use matrix_sdk::{
         },
         RoomId,
     },
-    store::{make_store_config, OpenStoreError},
-    Client, ClientBuildError, Error, HttpError, RumaApiError,
+    store::{MigrationConflictStrategy, OpenStoreError, StateStore},
+    Client, ClientBuildError, Error, HttpError, RumaApiError, StoreError,
 };
 use rand::{distributions::Alphanumeric, thread_rng, Rng};
 use thiserror::Error;
@@ -335,10 +335,13 @@ impl Session {
         };
 
         let handle = spawn_tokio!(async move {
-            let client = create_client(&homeserver, &path, &passphrase, use_discovery).await?;
+            let client =
+                create_client(&homeserver, path.clone(), passphrase.clone(), use_discovery).await?;
 
             let response = client
-                .login(&username, &password, None, Some("Fractal"))
+                .login_username(&username, &password)
+                .initial_device_display_name("Fractal")
+                .send()
                 .await;
             match response {
                 Ok(response) => Ok((
@@ -378,24 +381,23 @@ impl Session {
                 .collect()
         };
         let handle = spawn_tokio!(async move {
-            let client = create_client(&homeserver, &path, &passphrase, true).await?;
+            let client = create_client(&homeserver, path.clone(), passphrase.clone(), true).await?;
+
+            let mut login = client
+                .login_sso(|sso_url| async move {
+                    let ctx = glib::MainContext::default();
+                    ctx.spawn(async move {
+                        gtk::show_uri(gtk::Window::NONE, &sso_url, gdk::CURRENT_TIME);
+                    });
+                    Ok(())
+                })
+                .initial_device_display_name("Fractal");
 
-            let response = client
-                .login_with_sso(
-                    |sso_url| async move {
-                        let ctx = glib::MainContext::default();
-                        ctx.spawn(async move {
-                            gtk::show_uri(gtk::Window::NONE, &sso_url, gdk::CURRENT_TIME);
-                        });
-                        Ok(())
-                    },
-                    None,
-                    None,
-                    None,
-                    Some("Fractal"),
-                    idp_id.as_deref(),
-                )
-                .await;
+            if let Some(idp_id) = idp_id.as_deref() {
+                login = login.identity_provider_id(idp_id);
+            }
+
+            let response = login.send().await;
             match response {
                 Ok(response) => Ok((
                     client,
@@ -425,8 +427,8 @@ impl Session {
         let handle = spawn_tokio!(async move {
             let client = create_client(
                 &session.homeserver,
-                &session.path,
-                &session.secret.passphrase,
+                session.path.clone(),
+                session.secret.passphrase.clone(),
                 false,
             )
             .await?;
@@ -856,7 +858,7 @@ impl Session {
             glib::PRIORITY_DEFAULT_IDLE,
             clone!(@weak self as obj => async move {
                 let obj_weak = glib::SendWeakRef::from(obj.downgrade());
-                    obj.client().register_event_handler(
+                    obj.client().add_event_handler(
                         move |event: GlobalAccountDataEvent<DirectEventContent>| {
                             let obj_weak = obj_weak.clone();
                             async move {
@@ -889,23 +891,19 @@ impl Session {
         let client = self.client();
         spawn_tokio!(async move {
             client
-                .register_event_handler(
-                    move |_: SyncRoomEncryptionEvent, matrix_room: MatrixRoom| {
-                        let session_weak = session_weak.clone();
-                        async move {
-                            let ctx = glib::MainContext::default();
-                            ctx.spawn(async move {
-                                if let Some(session) = session_weak.upgrade() {
-                                    if let Some(room) =
-                                        session.room_list().get(matrix_room.room_id())
-                                    {
-                                        room.set_is_encrypted(true);
-                                    }
+                .add_event_handler(move |_: SyncRoomEncryptionEvent, matrix_room: MatrixRoom| {
+                    let session_weak = session_weak.clone();
+                    async move {
+                        let ctx = glib::MainContext::default();
+                        ctx.spawn(async move {
+                            if let Some(session) = session_weak.upgrade() {
+                                if let Some(room) = session.room_list().get(matrix_room.room_id()) {
+                                    room.set_is_encrypted(true);
                                 }
-                            });
-                        }
-                    },
-                )
+                            }
+                        });
+                    }
+                })
                 .await;
         });
     }
@@ -919,11 +917,20 @@ impl Default for Session {
 
 async fn create_client(
     homeserver: &Url,
-    path: &Path,
-    passphrase: &str,
+    path: PathBuf,
+    passphrase: String,
     use_discovery: bool,
 ) -> Result<Client, ClientSetupError> {
-    let store_config = make_store_config(path, Some(passphrase))?;
+    let state_store = StateStore::builder()
+        .path(path)
+        .passphrase(passphrase)
+        .migration_conflict_strategy(MigrationConflictStrategy::Drop)
+        .build()
+        .map_err(|err| OpenStoreError::from(StoreError::backend(err)))?;
+    let crypto_store = state_store.open_crypto_store()?;
+    let store_config = StoreConfig::new()
+        .state_store(state_store)
+        .crypto_store(crypto_store);
     Client::builder()
         .homeserver_url(homeserver)
         .store_config(store_config)

src/session/room/event.rs

@@ -11,14 +11,14 @@ use matrix_sdk::{
     ruma::{
         events::{
             room::{
-                encrypted::RoomEncryptedEventContent,
+                encrypted::OriginalSyncRoomEncryptedEvent,
                 message::{MessageType, Relation},
                 redaction::SyncRoomRedactionEvent,
             },
             AnyMessageLikeEventContent, AnySyncMessageLikeEvent, AnySyncRoomEvent,
-            AnySyncStateEvent, MessageLikeUnsigned, OriginalSyncMessageLikeEvent,
-            SyncMessageLikeEvent, SyncStateEvent,
+            AnySyncStateEvent, MessageLikeUnsigned, SyncMessageLikeEvent, SyncStateEvent,
         },
+        serde::Raw,
         MilliSecondsSinceUnixEpoch, OwnedEventId, OwnedTransactionId, OwnedUserId,
     },
     Error as MatrixError,
@@ -225,12 +225,12 @@ impl Event {
 
         if let Ok(deserialized) = event.event.deserialize() {
             if let AnySyncRoomEvent::MessageLike(AnySyncMessageLikeEvent::RoomEncrypted(
-                SyncMessageLikeEvent::Original(ref encrypted),
+                SyncMessageLikeEvent::Original(_),
             )) = deserialized
             {
-                let encrypted = encrypted.to_owned();
+                let raw_event = event.event.clone();
                 spawn!(clone!(@weak self as obj => async move {
-                    obj.try_to_decrypt(encrypted).await;
+                    obj.try_to_decrypt(raw_event.cast()).await;
                 }));
             }
 
@@ -246,7 +246,7 @@ impl Event {
         self.notify("source");
     }
 
-    async fn try_to_decrypt(&self, event: OriginalSyncMessageLikeEvent<RoomEncryptedEventContent>) {
+    async fn try_to_decrypt(&self, event: Raw<OriginalSyncRoomEncryptedEvent>) {
         let priv_ = self.imp();
         let room = self.room().matrix_room();
         let handle = spawn_tokio!(async move { room.decrypt_event(&event).await });

src/session/room/mod.rs

@@ -10,7 +10,7 @@ mod reaction_list;
 mod room_type;
 mod timeline;
 
-use std::{cell::RefCell, convert::TryInto, path::PathBuf};
+use std::{cell::RefCell, path::PathBuf};
 
 use gettextrs::{gettext, ngettext};
 use gtk::{glib, glib::clone, prelude::*, subclass::prelude::*};
@@ -23,7 +23,7 @@ use matrix_sdk::{
         api::client::sync::sync_events::v3::InvitedRoom,
         events::{
             reaction::{ReactionEventContent, Relation as ReactionRelation},
-            receipt::ReceiptEventContent,
+            receipt::{ReceiptEventContent, ReceiptType},
             room::{
                 member::MembershipState,
                 message::{MessageType, Relation},
@@ -38,7 +38,6 @@ use matrix_sdk::{
             MessageLikeUnsigned, OriginalSyncMessageLikeEvent, StateEventType,
             SyncMessageLikeEvent, SyncStateEvent, ToDeviceEvent,
         },
-        receipt::ReceiptType,
         serde::Raw,
         EventId, MilliSecondsSinceUnixEpoch, OwnedEventId, OwnedRoomId, OwnedUserId, RoomId,
     },
@@ -786,17 +785,16 @@ impl Room {
 
                 // Listen to changes in the read receipts.
                 let room_weak = glib::SendWeakRef::from(obj.downgrade());
-                obj.session().client().register_event_handler(
-                    move |event: SyncEphemeralRoomEvent<ReceiptEventContent>, matrix_room: MatrixRoom| {
+                obj.session().client().add_room_event_handler(
+                    obj.room_id(),
+                    move |event: SyncEphemeralRoomEvent<ReceiptEventContent>| {
                         let room_weak = room_weak.clone();
                         async move {
                             let ctx = glib::MainContext::default();
                             ctx.spawn(async move {
                                 spawn!(async move {
                                     if let Some(obj) = room_weak.upgrade() {
-                                        if matrix_room.room_id() == obj.room_id() {
-                                            obj.handle_receipt_event(event.content).await
-                                        }
+                                        obj.handle_receipt_event(event.content).await
                                     }
                                 });
                             });
@@ -1060,13 +1058,7 @@ impl Room {
                 return;
             }
         };
-        let room_name = match room_name.try_into() {
-            Ok(room_name) => room_name,
-            Err(e) => {
-                error!("Invalid room name: {}", e);
-                return;
-            }
-        };
+
         let name_content = RoomNameEventContent::new(Some(room_name));
 
         let handle =
@@ -1718,17 +1710,16 @@ impl Room {
             glib::PRIORITY_DEFAULT_IDLE,
             clone!(@weak self as obj => async move {
                 let obj_weak = glib::SendWeakRef::from(obj.downgrade());
-                    obj.session().client().register_event_handler(
-                        move |event: ToDeviceEvent<ToDeviceRoomKeyEventContent>| {
+                    obj.session().client().add_room_event_handler(
+                        obj.room_id(),
+                        move |_: ToDeviceEvent<ToDeviceRoomKeyEventContent>| {
                             let obj_weak = obj_weak.clone();
                             async move {
                                 let ctx = glib::MainContext::default();
                                 ctx.spawn(async move {
-                                        if let Some(room) = obj_weak.upgrade() {
-                                            if room.room_id() == event.content.room_id {
-                                                room.emit_by_name::<()>("new-encryption-keys", &[]);
-                                            }
-                                        }
+                                    if let Some(room) = obj_weak.upgrade() {
+                                        room.emit_by_name::<()>("new-encryption-keys", &[]);
+                                    }
                                 });
                             }
                         },

src/session/room_creation/mod.rs

@@ -1,9 +1,7 @@
-use std::convert::{TryFrom, TryInto};
-
 use adw::subclass::prelude::*;
 use gettextrs::gettext;
 use gtk::{gdk, glib, glib::clone, prelude::*, subclass::prelude::*, CompositeTemplate};
-use log::{error, warn};
+use log::error;
 use matrix_sdk::{
     ruma::{
         api::{
@@ -13,7 +11,7 @@ use matrix_sdk::{
             },
             error::{FromHttpResponseError, ServerError},
         },
-        assign, IdParseError, RoomName,
+        assign,
     },
     HttpError, RumaApiError,
 };
@@ -141,11 +139,6 @@ mod imp {
                     obj.create_room();
                 }));
 
-            self.room_name
-                .connect_text_notify(clone!(@weak obj = > move |_| {
-                    obj.validate_input();
-                }));
-
             self.room_address
                 .connect_text_notify(clone!(@weak obj = > move |_| {
                     obj.validate_input();
@@ -222,12 +215,9 @@ impl RoomCreation {
         };
 
         let handle = spawn_tokio!(async move {
-            // We don't allow invalid room names to be entered by the user
-            let name = room_name.as_str().try_into().unwrap();
-
             let request = assign!(create_room::v3::Request::new(),
             {
-                name: Some(name),
+                name: Some(&room_name),
                 visibility,
                 room_alias_name: room_address.as_deref()
             });
@@ -288,39 +278,11 @@ impl RoomCreation {
     fn validate_input(&self) {
         let priv_ = self.imp();
 
-        // Validate room name
-        let (is_name_valid, has_error) =
-            match <&RoomName>::try_from(priv_.room_name.text().as_str()) {
-                Ok(_) => (true, false),
-                Err(IdParseError::Empty) => (false, false),
-                Err(IdParseError::MaximumLengthExceeded) => {
-                    priv_
-                        .room_name_error
-                        .set_text(&gettext("Too long. Use a shorter name."));
-                    (false, true)
-                }
-                Err(error) => {
-                    warn!("Invalid room name: {error:?}");
-                    priv_
-                        .room_name_error
-                        .set_text(&gettext("Invalid room name."));
-                    (false, true)
-                }
-            };
-
-        if has_error {
-            priv_.room_name.add_css_class("error");
-        } else {
-            priv_.room_name.remove_css_class("error");
-        }
-
-        priv_.room_name_error_revealer.set_reveal_child(has_error);
-
         // Validate room address
 
         // Only public rooms have a address
         if priv_.private_button.is_active() {
-            priv_.create_button.set_sensitive(is_name_valid);
+            priv_.create_button.set_sensitive(false);
             return;
         }
 
@@ -360,9 +322,7 @@ impl RoomCreation {
         priv_
             .room_address_error_revealer
             .set_reveal_child(has_error);
-        priv_
-            .create_button
-            .set_sensitive(is_name_valid && is_address_valid);
+        priv_.create_button.set_sensitive(is_address_valid);
     }
 
     fn cancel(&self) {