chore: Upgrade matrix-sdk and ruma crates

And run `cargo upgrade` for other crates

Cargo.toml

@@ -65,7 +65,7 @@ sourceview = { package = "sourceview5", version = "0.8" }
 
 [dependencies.matrix-sdk]
 git = "https://github.com/matrix-org/matrix-rust-sdk.git"
-rev = "74931768e59d610588e9916289193aadffadad47"
+rev = "95a471b0d25535c227c503b37989adc9081a7fe5"
 features = [
     "socks",
     "sso-login",
@@ -76,14 +76,14 @@ features = [
 
 [dependencies.matrix-sdk-ui]
 git = "https://github.com/matrix-org/matrix-rust-sdk.git"
-rev = "74931768e59d610588e9916289193aadffadad47"
+rev = "95a471b0d25535c227c503b37989adc9081a7fe5"
 default-features = false
 features = ["e2e-encryption", "native-tls"]
 
 [dependencies.ruma]
 # version = "0.9.4"
 git = "https://github.com/ruma/ruma.git"
-rev = "68c9bb0930f2195fa8672fbef9633ef62737df5d"
+rev = "4c00bd010dbdca6005bd599b52e90a0b7015d056"
 features = [
     "unstable-unspecified",
     "client-api-c",

src/login/homeserver_page.rs

@@ -4,9 +4,9 @@ use gtk::{self, glib, glib::clone, CompositeTemplate};
 use matrix_sdk::{
     config::RequestConfig, sanitize_server_name, Client, ClientBuildError, ClientBuilder,
 };
-use ruma::{api::client::discovery::get_supported_versions, OwnedServerName};
+use ruma::api::client::discovery::get_supported_versions;
 use tracing::warn;
-use url::{ParseError, Url};
+use url::Url;
 
 use super::Login;
 use crate::{
@@ -134,16 +134,6 @@ impl LoginHomeserverPage {
         self.update_next_state();
     }
 
-    /// The server name entered by the user, if any.
-    pub fn server_name(&self) -> Option<OwnedServerName> {
-        sanitize_server_name(self.imp().homeserver_entry.text().as_str()).ok()
-    }
-
-    /// The homeserver URL entered by the user, if any.
-    pub fn homeserver_url(&self) -> Option<Url> {
-        build_homeserver_url(self.imp().homeserver_entry.text().as_str()).ok()
-    }
-
     /// Whether the current state allows to go to the next step.
     fn can_go_next(&self) -> bool {
         let Some(login) = self.login() else {
@@ -153,9 +143,8 @@ impl LoginHomeserverPage {
 
         if login.autodiscovery() {
             sanitize_server_name(homeserver.as_str()).is_ok()
-                || build_homeserver_url(homeserver.as_str()).is_ok()
         } else {
-            build_homeserver_url(homeserver.as_str()).is_ok()
+            Url::parse(homeserver.as_str()).is_ok()
         }
     }
 
@@ -192,13 +181,15 @@ impl LoginHomeserverPage {
         let res = if autodiscovery {
             self.discover_homeserver().await
         } else {
-            self.detect_homeserver(self.homeserver_url().unwrap(), false)
-                .await
-                .map(|c| (c, None))
+            self.detect_homeserver().await
         };
 
         match res {
-            Ok((client, server_name)) => {
+            Ok(client) => {
+                let server_name = autodiscovery
+                    .then(|| self.imp().homeserver_entry.text())
+                    .and_then(|s| sanitize_server_name(&s).ok());
+
                 login.set_domain(server_name);
                 login.set_client(Some(client.clone()));
 
@@ -213,68 +204,32 @@ impl LoginHomeserverPage {
         login.unfreeze();
     }
 
-    async fn discover_homeserver(
-        &self,
-    ) -> Result<(Client, Option<OwnedServerName>), ClientBuildError> {
-        let mut discovery_error = None;
-        let mut server_error = None;
-
-        // Try to discover the server.
-        if let Some(server_name) = self.server_name() {
-            let server_name_clone = server_name.clone();
-            let handle = spawn_tokio!(async move {
-                client_builder()
-                    .respect_login_well_known(true)
-                    .server_name(&server_name_clone)
-                    .build()
-                    .await
-            });
-
-            match handle.await.unwrap() {
-                Ok(client) => return Ok((client, Some(server_name))),
-                Err(error) => {
-                    discovery_error = Some(error);
-                }
-            }
-        }
-
-        // Check if it is a valid homeserver URL.
-        if let Some(homeserver_url) = self.homeserver_url() {
-            match self.detect_homeserver(homeserver_url, true).await {
-                Ok(client) => return Ok((client, None)),
-                Err(error) => {
-                    server_error = Some(error);
-                }
-            }
-        }
+    /// Try to discover the homeserver.
+    async fn discover_homeserver(&self) -> Result<Client, ClientBuildError> {
+        let homeserver = self.imp().homeserver_entry.text();
+        let handle = spawn_tokio!(async move {
+            client_builder()
+                .server_name_or_homeserver_url(homeserver)
+                .build()
+                .await
+        });
 
-        match (discovery_error, server_error) {
-            (Some(discovery_error), Some(server_error)) => {
-                warn!("Could not discover homeserver. Auto-discovery error: {discovery_error}. Homeserver detection error: {server_error}");
-                Err(discovery_error)
-            }
-            (Some(discovery_error), None) => {
-                warn!("Could not discover homeserver. Auto-discovery error: {discovery_error}");
-                Err(discovery_error)
-            }
-            (None, Some(server_error)) => {
-                warn!("Could not discover homeserver. Homeserver detection error: {server_error}");
-                Err(server_error)
+        match handle.await.unwrap() {
+            Ok(client) => Ok(client),
+            Err(error) => {
+                warn!("Could not discover homeserver: {error}");
+                Err(error)
             }
-            // We should have at least one error at this step.
-            _ => unreachable!(),
         }
     }
 
-    async fn detect_homeserver(
-        &self,
-        url: Url,
-        autodiscovery: bool,
-    ) -> Result<Client, ClientBuildError> {
+    /// Check if the URL points to a homeserver.
+    async fn detect_homeserver(&self) -> Result<Client, ClientBuildError> {
+        let homeserver = self.imp().homeserver_entry.text();
         spawn_tokio!(async move {
             let client = client_builder()
-                .respect_login_well_known(autodiscovery)
-                .homeserver_url(url)
+                .respect_login_well_known(false)
+                .homeserver_url(homeserver)
                 .build()
                 .await?;
 
@@ -312,14 +267,6 @@ impl LoginHomeserverPage {
     }
 }
 
-fn build_homeserver_url(server: &str) -> Result<Url, ParseError> {
-    if server.starts_with("http://") || server.starts_with("https://") {
-        Url::parse(server)
-    } else {
-        Url::parse(&format!("https://{server}"))
-    }
-}
-
 fn client_builder() -> ClientBuilder {
     Client::builder().request_config(RequestConfig::new().retry_limit(2))
 }

src/session/model/remote_user.rs

@@ -44,11 +44,14 @@ impl RemoteUser {
 
     /// Request this user's profile from the homeserver.
     pub async fn load_profile(&self) {
-        let client = self.session().client();
         let user_id = self.user_id();
 
+        let client = self.session().client();
         let user_id_clone = user_id.clone();
-        let handle = spawn_tokio!(async move { client.get_profile(&user_id_clone).await });
+        let handle =
+            spawn_tokio!(
+                async move { client.account().fetch_user_profile_of(&user_id_clone).await }
+            );
 
         let profile = match handle.await.unwrap() {
             Ok(profile) => profile,

src/session/model/session.rs

@@ -217,7 +217,12 @@ impl Session {
 
     /// Finish initialization of this session.
     pub async fn prepare(&self) {
-        self.update_user_profile();
+        spawn!(
+            glib::Priority::LOW,
+            clone!(@weak self as obj => async move {
+                obj.update_user_profile().await;
+            })
+        );
         self.update_offline().await;
 
         self.room_list().load().await;
@@ -330,21 +335,19 @@ impl Session {
     /// Update the profile of this session’s user.
     ///
     /// Fetches the updated profile and updates the local data.
-    pub fn update_user_profile(&self) {
+    async fn update_user_profile(&self) {
         let client = self.client();
-        let user = self.user();
+        let handle = spawn_tokio!(async move { client.account().fetch_user_profile().await });
 
-        let handle = spawn_tokio!(async move { client.account().get_profile().await });
+        match handle.await.unwrap() {
+            Ok(res) => {
+                let user = self.user();
 
-        spawn!(glib::Priority::LOW, async move {
-            match handle.await.unwrap() {
-                Ok(res) => {
-                    user.set_name(res.displayname);
-                    user.set_avatar_url(res.avatar_url);
-                }
-                Err(error) => error!("Could not fetch account metadata: {error}"),
+                user.set_name(res.displayname);
+                user.set_avatar_url(res.avatar_url);
             }
-        });
+            Err(error) => error!("Could not fetch account metadata: {error}"),
+        }
     }
 
     /// The Matrix client.

src/session/model/user.rs

@@ -295,24 +295,27 @@ pub trait UserExt: IsA<User> {
     /// Load the user profile from the homeserver.
     ///
     /// This overwrites the already loaded display name and avatar.
-    fn load_profile(&self) {
+    async fn load_profile(&self) {
+        let user_id = self.user_id();
+
         let client = self.session().client();
-        let user_id = self.user_id().clone();
-        let user = self.upcast_ref::<User>();
-
-        let handle = spawn_tokio!(async move { client.get_profile(&user_id).await });
-
-        spawn!(clone!(@weak user => async move {
-            match handle.await.unwrap() {
-                Ok(response) => {
-                    user.set_name(response.displayname);
-                    user.set_avatar_url(response.avatar_url);
-                },
-                Err(error) => {
-                    error!("Could not load user profile for {}: {}", user.user_id(), error);
-                }
-            };
-        }));
+        let user_id_clone = user_id.clone();
+        let handle =
+            spawn_tokio!(
+                async move { client.account().fetch_user_profile_of(&user_id_clone).await }
+            );
+
+        match handle.await.unwrap() {
+            Ok(response) => {
+                let user = self.upcast_ref::<User>();
+
+                user.set_name(response.displayname);
+                user.set_avatar_url(response.avatar_url);
+            }
+            Err(error) => {
+                error!("Could not load user profile for {user_id}: {error}");
+            }
+        };
     }
 
     /// Whether this user is currently ignored.

src/session/view/create_dm_dialog/dm_user_list.rs

@@ -181,7 +181,9 @@ impl DmUserList {
                     // If it is the "custom user" from the search term, fetch the avatar
                     // and display name
                     if add_custom && *user.user_id() == search_term {
-                        user.load_profile();
+                        spawn!(clone!(@weak user => async move {
+                            user.load_profile().await;
+                        }));
                     }
 
                     users.push(user);