feat: Add Account::fetch_account_data_static

It uses the statically-known type from the `StaticEventContent`
implementation to call `fetch_account_data()`.

This is the equivalent of `Account::account_data()` but for fetching
from the server. It avoids the need to cast to the proper type after.

Signed-off-by: Kévin Commaille <[email protected]>

Author: zecakeh

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

@@ -75,7 +75,6 @@ use ruma::{
         },
         tag::TagEventContent,
         GlobalAccountDataEvent as RumaGlobalAccountDataEvent,
-        GlobalAccountDataEventType as RumaGlobalAccountDataEventType,
         RoomAccountDataEvent as RumaRoomAccountDataEvent,
     },
     push::{HttpPusherData as RumaHttpPusherData, PushFormat as RumaPushFormat},
@@ -1253,13 +1252,10 @@ impl Client {
     // Ignored users
 
     pub async fn ignored_users(&self) -> Result<Vec<String>, ClientError> {
-        if let Some(raw_content) = self
-            .inner
-            .account()
-            .fetch_account_data(RumaGlobalAccountDataEventType::IgnoredUserList)
-            .await?
+        if let Some(raw_content) =
+            self.inner.account().fetch_account_data_static::<IgnoredUserListEventContent>().await?
         {
-            let content = raw_content.deserialize_as::<IgnoredUserListEventContent>()?;
+            let content = raw_content.deserialize()?;
             let user_ids: Vec<String> =
                 content.ignored_users.keys().map(|id| id.to_string()).collect();
 

crates/matrix-sdk/CHANGELOG.md

@@ -8,6 +8,10 @@ All notable changes to this project will be documented in this file.
 
 ### Features
 
+- Add `Account::fetch_account_data_static` to fetch account data from the server
+  with a statically-known type, with a signature similar to
+  `Account::account_data`.
+  ([#5424](https://github.com/matrix-org/matrix-rust-sdk/pull/5424))
 - Add support to accept historic room key bundles that arrive out of order, i.e.
   the bundle arrives after the invite has already been accepted.
   ([#5322](https://github.com/matrix-org/matrix-rust-sdk/pull/5322))

crates/matrix-sdk/src/account.rs

@@ -698,7 +698,8 @@ impl Account {
         Ok(self.client.send(request).await?)
     }
 
-    /// Get the content of an account data event of statically-known type.
+    /// Get the content of an account data event of statically-known type, from
+    /// storage.
     ///
     /// # Examples
     ///
@@ -726,7 +727,7 @@ impl Account {
         get_raw_content(self.client.state_store().get_account_data_event_static::<C>().await?)
     }
 
-    /// Get the content of an account data event of a given type.
+    /// Get the content of an account data event of a given type, from storage.
     pub async fn account_data_raw(
         &self,
         event_type: GlobalAccountDataEventType,
@@ -781,6 +782,14 @@ impl Account {
         }
     }
 
+    /// Fetch an account data event of statically-known type from the server.
+    pub async fn fetch_account_data_static<C>(&self) -> Result<Option<Raw<C>>>
+    where
+        C: GlobalAccountDataEventContent + StaticEventContent,
+    {
+        Ok(self.fetch_account_data(C::TYPE.into()).await?.map(Raw::cast))
+    }
+
     /// Set the given account data event.
     ///
     /// # Examples
@@ -862,12 +871,12 @@ impl Account {
 
         // We are fetching the content from the server because we currently can't rely
         // on `/sync` giving us the correct data in a timely manner.
-        let raw_content = self.fetch_account_data(GlobalAccountDataEventType::Direct).await?;
+        let raw_content = self.fetch_account_data_static::<DirectEventContent>().await?;
 
         let mut content = if let Some(raw_content) = raw_content {
             // Log the error and pass it upwards if we fail to deserialize the m.direct
             // event.
-            raw_content.deserialize_as::<DirectEventContent>().map_err(|err| {
+            raw_content.deserialize().map_err(|err| {
                 error!("unable to deserialize m.direct event content; aborting request to mark {room_id} as dm: {err}");
                 err
             })?
@@ -1081,21 +1090,22 @@ impl Account {
     pub async fn fetch_media_preview_config_event_content(
         &self,
     ) -> Result<Option<MediaPreviewConfigEventContent>> {
-        // First we check if there is avalue in the stable event
+        // First we check if there is a value in the stable event
         let media_preview_config =
-            self.fetch_account_data(GlobalAccountDataEventType::MediaPreviewConfig).await?;
+            self.fetch_account_data_static::<MediaPreviewConfigEventContent>().await?;
 
         let media_preview_config = if let Some(media_preview_config) = media_preview_config {
             Some(media_preview_config)
         } else {
             // If there is no value in the stable event, we check the unstable
-            self.fetch_account_data(GlobalAccountDataEventType::UnstableMediaPreviewConfig).await?
+            self.fetch_account_data_static::<UnstableMediaPreviewConfigEventContent>()
+                .await?
+                .map(Raw::cast)
         };
 
         // We deserialize the content of the event, if is not found we return the
         // default
-        let media_preview_config = media_preview_config
-            .and_then(|value| value.deserialize_as::<MediaPreviewConfigEventContent>().ok());
+        let media_preview_config = media_preview_config.and_then(|value| value.deserialize().ok());
 
         Ok(media_preview_config)
     }

crates/matrix-sdk/src/encryption/recovery/mod.rs

@@ -408,7 +408,7 @@ impl Recovery {
     /// # let client = Client::new(homeserver).await?;
     /// # let user_id = unimplemented!();
     /// let encryption = client.encryption();
-    ///       
+    ///
     /// if let Some(handle) = encryption.recovery().reset_identity().await? {
     ///     match handle.auth_type() {
     ///         CrossSigningResetAuthType::Uiaa(uiaa) => {
@@ -592,14 +592,9 @@ impl Recovery {
         Ok(self
             .client
             .account()
-            .fetch_account_data(BackupDisabledContent::event_type())
+            .fetch_account_data_static::<BackupDisabledContent>()
             .await?
-            .map(|event| {
-                event
-                    .deserialize_as::<BackupDisabledContent>()
-                    .map(|event| event.disabled)
-                    .unwrap_or(false)
-            })
+            .map(|event| event.deserialize().map(|event| event.disabled).unwrap_or(false))
             .unwrap_or(false))
     }
 

crates/matrix-sdk/src/encryption/recovery/types.rs

@@ -13,10 +13,7 @@
 // limitations under the License.
 
 use matrix_sdk_base::crypto::store::types::RoomKeyCounts;
-use ruma::{
-    events::{EventContent, GlobalAccountDataEventType},
-    exports::ruma_macros::EventContent,
-};
+use ruma::exports::ruma_macros::EventContent;
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
 use zeroize::{Zeroize, ZeroizeOnDrop};
@@ -115,12 +112,3 @@ pub(super) struct SecretStorageDisabledContent {}
 pub(super) struct BackupDisabledContent {
     pub disabled: bool,
 }
-
-impl BackupDisabledContent {
-    /// Get the event type of the [`BackupDisabledContent`] global account data
-    /// event.
-    pub(super) fn event_type() -> GlobalAccountDataEventType {
-        // This is dumb, there's got to be a better way to get to the event type?
-        Self { disabled: false }.event_type()
-    }
-}

crates/matrix-sdk/src/encryption/secret_storage/mod.rs

@@ -283,12 +283,9 @@ impl SecretStorage {
     pub async fn fetch_default_key_id(
         &self,
     ) -> crate::Result<Option<Raw<SecretStorageDefaultKeyEventContent>>> {
-        let maybe_default_key_id = self
-            .client
+        self.client
             .account()
-            .fetch_account_data(GlobalAccountDataEventType::SecretStorageDefaultKey)
-            .await?;
-
-        Ok(maybe_default_key_id.map(|event| event.cast()))
+            .fetch_account_data_static::<SecretStorageDefaultKeyEventContent>()
+            .await
     }
 }