feat: implement and observe MSC 4278 config value

Author: Velin92

Cargo.lock

@@ -61,7 +61,7 @@ reqwest = { version = "0.12.12", default-features = false }
 rmp-serde = "1.3.0"
 # Be careful to use commits from the https://github.com/ruma/ruma/tree/ruma-0.12
 # branch until a proper release with breaking changes happens.
-ruma = { git = "https://github.com/ruma/ruma", rev = "689d9613a985edc089b5b729e6d9362f09b5df4f", features = [
+ruma = { git = "https://github.com/ruma/ruma", rev = "a8fd1b0322649bf59e2a5cfc73ab4fe46b21edd7", features = [
     "client-api-c",
     "compat-upload-signatures",
     "compat-user-id",
@@ -77,7 +77,7 @@ ruma = { git = "https://github.com/ruma/ruma", rev = "689d9613a985edc089b5b729e6
     "unstable-msc4171",
     "unstable-msc4278",
     ] }
-ruma-common = { git = "https://github.com/ruma/ruma", rev = "689d9613a985edc089b5b729e6d9362f09b5df4f" }
+ruma-common = { git = "https://github.com/ruma/ruma", rev = "a8fd1b0322649bf59e2a5cfc73ab4fe46b21edd7" }
 serde = "1.0.217"
 serde_html_form = "0.2.7"
 serde_json = "1.0.138"

Cargo.toml

@@ -6,7 +6,7 @@ use std::{
 
 use anyhow::{anyhow, Context as _};
 use async_compat::get_runtime_handle;
-use futures_util::StreamExt;
+use futures_util::{pin_mut, StreamExt};
 use matrix_sdk::{
     authentication::oauth::{
         AccountManagementActionFull, ClientId, OAuthAuthorizationData, OAuthSession,
@@ -89,8 +89,8 @@ use crate::{
     room_directory_search::RoomDirectorySearch,
     room_preview::RoomPreview,
     ruma::{
-        AccountDataEvent, AccountDataEventType, AuthData, MediaSource, RoomAccountDataEvent,
-        RoomAccountDataEventType,
+        AccountDataEvent, AccountDataEventType, AuthData, InviteAvatars, MediaPreviewConfig,
+        MediaPreviews, MediaSource, RoomAccountDataEvent, RoomAccountDataEventType,
     },
     sync_service::{SyncService, SyncServiceBuilder},
     task_handle::TaskHandle,
@@ -1373,6 +1373,46 @@ impl Client {
     pub async fn is_report_room_api_supported(&self) -> Result<bool, ClientError> {
         Ok(self.inner.server_versions().await?.contains(&ruma::api::MatrixVersion::V1_13))
     }
+
+    /// Subscribe to changes in the media preview configuration.
+    pub async fn subscribe_to_media_preview_config(
+        &self,
+        listener: Box<dyn MediaPreviewConfigListener>,
+    ) -> Result<Arc<TaskHandle>, ClientError> {
+        let (initial_value, stream) = self.inner.account().observe_media_preview_config().await?;
+        Ok(Arc::new(TaskHandle::new(get_runtime_handle().spawn(async move {
+            // Send the initial value to the listener.
+            listener.on_change(initial_value.into());
+            // Listen for changes and notify the listener.
+            pin_mut!(stream);
+            while let Some(media_preview_config) = stream.next().await {
+                listener.on_change(media_preview_config.into());
+            }
+        }))))
+    }
+
+    /// Set the media previews timeline display policy
+    pub async fn set_media_preview_display_policy(
+        &self,
+        policy: MediaPreviews,
+    ) -> Result<(), ClientError> {
+        self.inner.account().set_media_previews_display_policy(policy.into()).await?;
+        Ok(())
+    }
+
+    /// Get the media previews timeline display policy
+    pub async fn set_invite_avatars_display_policy(
+        &self,
+        policy: InviteAvatars,
+    ) -> Result<(), ClientError> {
+        self.inner.account().set_invite_avatars_display_policy(policy.into()).await?;
+        Ok(())
+    }
+}
+
+#[matrix_sdk_ffi_macros::export(callback_interface)]
+pub trait MediaPreviewConfigListener: Sync + Send {
+    fn on_change(&self, media_preview_config: MediaPreviewConfig);
 }
 
 #[matrix_sdk_ffi_macros::export(callback_interface)]

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

@@ -30,6 +30,10 @@ use ruma::{
         ignored_user_list::{IgnoredUser as RumaIgnoredUser, IgnoredUserListEventContent},
         location::AssetType as RumaAssetType,
         marked_unread::{MarkedUnreadEventContent, UnstableMarkedUnreadEventContent},
+        media_preview_config::{
+            InviteAvatars as RumaInviteAvatars, MediaPreviewConfigEventContent,
+            MediaPreviews as RumaMediaPreviews,
+        },
         poll::start::PollKind as RumaPollKind,
         push_rules::PushRulesEventContent,
         room::{
@@ -1104,6 +1108,61 @@ pub enum AccountDataEvent {
     },
 }
 
+#[derive(Clone, uniffi::Enum, Default)]
+pub enum MediaPreviews {
+    #[default]
+    On,
+    Private,
+    Off,
+}
+
+impl From<RumaMediaPreviews> for MediaPreviews {
+    fn from(value: RumaMediaPreviews) -> Self {
+        match value {
+            RumaMediaPreviews::On => Self::On,
+            RumaMediaPreviews::Private => Self::Private,
+            RumaMediaPreviews::Off => Self::Off,
+            _ => Default::default(),
+        }
+    }
+}
+
+impl From<MediaPreviews> for RumaMediaPreviews {
+    fn from(value: MediaPreviews) -> Self {
+        match value {
+            MediaPreviews::On => Self::On,
+            MediaPreviews::Private => Self::Private,
+            MediaPreviews::Off => Self::Off,
+        }
+    }
+}
+
+#[derive(Clone, uniffi::Enum, Default)]
+pub enum InviteAvatars {
+    #[default]
+    On,
+    Off,
+}
+
+impl From<RumaInviteAvatars> for InviteAvatars {
+    fn from(value: RumaInviteAvatars) -> Self {
+        match value {
+            RumaInviteAvatars::On => Self::On,
+            RumaInviteAvatars::Off => Self::Off,
+            _ => Default::default(),
+        }
+    }
+}
+
+impl From<InviteAvatars> for RumaInviteAvatars {
+    fn from(value: InviteAvatars) -> Self {
+        match value {
+            InviteAvatars::On => Self::On,
+            InviteAvatars::Off => Self::Off,
+        }
+    }
+}
+
 /// Details about an ignored user.
 ///
 /// This is currently empty.
@@ -1351,6 +1410,24 @@ impl From<RumaSecretStorageV1AesHmacSha2Properties> for SecretStorageV1AesHmacSh
     }
 }
 
+#[derive(Clone, uniffi::Record, Default)]
+pub struct MediaPreviewConfig {
+    /// The media previews setting for the user.
+    pub media_previews: MediaPreviews,
+
+    /// The invite avatars setting for the user.
+    pub invite_avatars: InviteAvatars,
+}
+
+impl From<MediaPreviewConfigEventContent> for MediaPreviewConfig {
+    fn from(value: MediaPreviewConfigEventContent) -> Self {
+        Self {
+            media_previews: value.media_previews.into(),
+            invite_avatars: value.invite_avatars.into(),
+        }
+    }
+}
+
 /// A passphrase from which a key is to be derived.
 #[derive(Clone, uniffi::Record)]
 pub struct PassPhrase {

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

@@ -14,6 +14,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use futures_core::Stream;
+use futures_util::{stream, StreamExt};
 use matrix_sdk_base::{
     media::{MediaFormat, MediaRequestParameters},
     store::StateStoreExt,
@@ -36,9 +38,13 @@ use ruma::{
     assign,
     events::{
         ignored_user_list::{IgnoredUser, IgnoredUserListEventContent},
+        media_preview_config::{
+            InviteAvatars, MediaPreviewConfigEventContent, MediaPreviews,
+            UnstableMediaPreviewConfigEventContent,
+        },
         push_rules::PushRulesEventContent,
         room::MediaSource,
-        AnyGlobalAccountDataEventContent, GlobalAccountDataEventContent,
+        AnyGlobalAccountDataEventContent, GlobalAccountDataEvent, GlobalAccountDataEventContent,
         GlobalAccountDataEventType, StaticEventContent,
     },
     push::Ruleset,
@@ -980,6 +986,107 @@ impl Account {
             .await?;
         Ok(())
     }
+
+    /// Observes the media preview configuration.
+    ///
+    /// This will return the initial value of the configuration and a stream
+    /// that will yield new values as they are received.
+    ///
+    /// The initial value is the one that was stored in the account data
+    /// when the client was started. If no value was found in either the stable
+    /// and unstable type, the default configuration will be returned.
+    /// This is a temporary solution until we know which matrix version will
+    /// support the stable type.
+    pub async fn observe_media_preview_config(
+        &self,
+    ) -> Result<
+        (MediaPreviewConfigEventContent, impl Stream<Item = MediaPreviewConfigEventContent>),
+        Error,
+    > {
+        // First we check if there is avalue in the stable event
+        let initial_value =
+            self.fetch_account_data(GlobalAccountDataEventType::MediaPreviewConfig).await?;
+
+        let initial_value = if let Some(initial_value) = initial_value {
+            Some(initial_value)
+        } else {
+            // If there is no value in the stable event, we check the unstable
+            self.fetch_account_data(GlobalAccountDataEventType::UnstableMediaPreviewConfig).await?
+        };
+
+        // We deserialize the content of the event, if is not found we return the
+        // default
+        let initial_value = initial_value
+            .and_then(|value| value.deserialize_as::<MediaPreviewConfigEventContent>().ok())
+            .unwrap_or_default();
+
+        // We need to create two observers, one for the stable event and one for the
+        // unstable and combine them into a single stream.
+        let first_observer = self
+            .client
+            .observe_events::<GlobalAccountDataEvent<MediaPreviewConfigEventContent>, ()>();
+
+        let stream = first_observer.subscribe().map(|event| event.0.content);
+
+        let second_observer = self
+            .client
+            .observe_events::<GlobalAccountDataEvent<UnstableMediaPreviewConfigEventContent>, ()>();
+
+        let second_stream = second_observer.subscribe().map(|event| event.0.content.0);
+
+        let mut combined_stream = stream::select(stream, second_stream);
+
+        let result_stream = async_stream::stream! {
+            // The observers need to be alive for the individual streams to be alive, so let's now
+            // create a stream that takes ownership of them.
+            let _first_observer = first_observer;
+            let _second_observer = second_observer;
+
+            while let Some(item) = combined_stream.next().await {
+                yield item
+            }
+        };
+
+        Ok((initial_value, result_stream))
+    }
+
+    /// Set the media previews display policy in the timeline.
+    ///
+    /// This will always use the unstable event until we know which matrix
+    /// version will support it.
+    pub async fn set_media_previews_display_policy(&self, policy: MediaPreviews) -> Result<()> {
+        let mut media_preview_config = self.get_media_preview_config_event_content().await?;
+        media_preview_config.0.media_previews = policy;
+
+        // Updating the account data
+        self.set_account_data(media_preview_config).await?;
+        Ok(())
+    }
+
+    /// Set the display policy for avatars in invite requests.
+    ///
+    /// This will always use the unstable event until we know which matrix
+    /// version will support it.
+    pub async fn set_invite_avatars_display_policy(&self, policy: InviteAvatars) -> Result<()> {
+        let mut media_preview_config = self.get_media_preview_config_event_content().await?;
+        media_preview_config.0.invite_avatars = policy;
+
+        // Updating the account data
+        self.set_account_data(media_preview_config).await?;
+        Ok(())
+    }
+
+    async fn get_media_preview_config_event_content(
+        &self,
+    ) -> Result<UnstableMediaPreviewConfigEventContent> {
+        let media_preview_config = self
+            .account_data::<UnstableMediaPreviewConfigEventContent>()
+            .await?
+            .map(|c| c.deserialize())
+            .transpose()?
+            .unwrap_or_default();
+        Ok(media_preview_config)
+    }
 }
 
 fn get_raw_content<Ev, C>(raw: Option<Raw<Ev>>) -> Result<Option<Raw<C>>> {