refactor(timeline): allow creating a TimelineItemContent from a sdk::TimelineEvent

Author: bnjbvr

crates/matrix-sdk-ui/src/timeline/event_item/content/mod.rs

@@ -15,16 +15,18 @@
 use std::sync::Arc;
 
 use as_variant::as_variant;
+use matrix_sdk::{Room, deserialized_responses::TimelineEvent};
 use matrix_sdk_base::crypto::types::events::UtdCause;
 use ruma::{
     OwnedDeviceId, OwnedEventId, OwnedMxcUri, OwnedUserId, UserId,
     events::{
-        AnyStateEventContentChange, Mentions, MessageLikeEventType, StateEventContentChange,
-        StateEventType,
+        AnyMessageLikeEventContent, AnyStateEventContentChange, Mentions, MessageLikeEventType,
+        StateEventContentChange, StateEventType,
         policy::rule::{
             room::PolicyRuleRoomEventContent, server::PolicyRuleServerEventContent,
             user::PolicyRuleUserEventContent,
         },
+        relation::Replacement,
         room::{
             aliases::RoomAliasesEventContent,
             avatar::RoomAvatarEventContent,
@@ -36,7 +38,7 @@ use ruma::{
             history_visibility::RoomHistoryVisibilityEventContent,
             join_rules::RoomJoinRulesEventContent,
             member::{Change, RoomMemberEventContent},
-            message::MessageType,
+            message::{MessageType, RoomMessageEventContent},
             name::RoomNameEventContent,
             pinned_events::RoomPinnedEventsEventContent,
             power_levels::RoomPowerLevelsEventContent,
@@ -77,6 +79,7 @@ pub use self::{
     reply::{EmbeddedEvent, InReplyToDetails},
 };
 use super::ReactionsByKeyBySender;
+use crate::timeline::event_handler::{HandleAggregationKind, TimelineAction};
 
 /// The content of an [`EventTimelineItem`][super::EventTimelineItem].
 #[allow(clippy::large_enum_variant)]
@@ -147,6 +150,49 @@ impl TimelineItemContent {
         }
     }
 
+    /// Create a raw [`TimelineItemContent`] for a given [`TimelineEvent`],
+    /// without providing extra information (about thread root, replied-to
+    /// information, UTD info, and so on).
+    pub async fn from_event(room: &Room, timeline_event: TimelineEvent) -> Option<Self> {
+        let raw_event = timeline_event.into_raw();
+        let deserialized_event = raw_event.deserialize().ok()?;
+
+        match TimelineAction::from_event(
+            deserialized_event,
+            &raw_event,
+            room,
+            None,
+            None,
+            None,
+            None,
+        )
+        .await
+        {
+            Some(TimelineAction::AddItem { content }) => Some(content),
+
+            // Aggregated event: only edits are supported at the moment.
+            Some(TimelineAction::HandleAggregation {
+                kind: HandleAggregationKind::Edit { replacement: Replacement { new_content, .. } },
+                ..
+            }) => {
+                // Map the edit to a regular message.
+                match TimelineAction::from_content(
+                    AnyMessageLikeEventContent::RoomMessage(RoomMessageEventContent::new(
+                        new_content.msgtype,
+                    )),
+                    None,
+                    None,
+                    None,
+                ) {
+                    TimelineAction::AddItem { content } => Some(content),
+                    _ => None,
+                }
+            }
+
+            _ => None,
+        }
+    }
+
     pub fn as_msglike(&self) -> Option<&MsgLikeContent> {
         as_variant!(self, TimelineItemContent::MsgLike)
     }

crates/matrix-sdk-ui/src/timeline/event_item/mod.rs

@@ -20,7 +20,7 @@ use std::{
 use as_variant::as_variant;
 use indexmap::IndexMap;
 use matrix_sdk::{
-    Error,
+    Error, Room,
     deserialized_responses::{EncryptionInfo, ShieldState},
     send_queue::{SendHandle, SendReactionHandle},
 };
@@ -32,6 +32,7 @@ use ruma::{
     room_version_rules::RedactionRules,
     serde::Raw,
 };
+use tracing::error;
 use unicode_segmentation::UnicodeSegmentation;
 
 mod content;
@@ -643,6 +644,24 @@ pub struct Profile {
     pub avatar_url: Option<OwnedMxcUri>,
 }
 
+impl Profile {
+    pub async fn load(room: &Room, user_id: &UserId) -> Option<Self> {
+        match room.get_member_no_sync(user_id).await {
+            Ok(Some(member)) => Some(Profile {
+                display_name: member.display_name().map(ToOwned::to_owned),
+                display_name_ambiguous: member.name_ambiguous(),
+                avatar_url: member.avatar_url().map(ToOwned::to_owned),
+            }),
+            Ok(None) if room.are_members_synced() => Some(Profile::default()),
+            Ok(None) => None,
+            Err(e) => {
+                error!(%user_id, "Failed to fetch room member information: {e}");
+                None
+            }
+        }
+    }
+}
+
 /// Some details of an [`EventTimelineItem`] that may require server requests
 /// other than just the regular
 /// [`sync_events`][ruma::api::client::sync::sync_events].

crates/matrix-sdk-ui/src/timeline/latest_event.rs

@@ -14,18 +14,11 @@
 
 use matrix_sdk::{Client, Room, latest_events::LocalLatestEventValue};
 use matrix_sdk_base::latest_event::LatestEventValue as BaseLatestEventValue;
-use ruma::{
-    MilliSecondsSinceUnixEpoch, OwnedUserId,
-    events::{
-        AnyMessageLikeEventContent, relation::Replacement, room::message::RoomMessageEventContent,
-    },
-};
+use ruma::{MilliSecondsSinceUnixEpoch, OwnedUserId};
 use tracing::trace;
 
 use crate::timeline::{
-    Profile, TimelineDetails, TimelineItemContent,
-    event_handler::{HandleAggregationKind, TimelineAction},
-    traits::RoomDataProvider,
+    Profile, TimelineDetails, TimelineItemContent, event_handler::TimelineAction,
 };
 
 /// A simplified version of [`matrix_sdk_base::latest_event::LatestEventValue`]
@@ -111,77 +104,17 @@ impl LatestEventValue {
                 };
                 let is_own = client.user_id().map(|user_id| user_id == sender).unwrap_or(false);
 
-                let raw_any_sync_timeline_event = timeline_event.into_raw();
-                let Ok(any_sync_timeline_event) = raw_any_sync_timeline_event.deserialize() else {
-                    return Self::None;
-                };
-                let profile = room
-                    .profile_from_user_id(&sender)
-                    .await
-                    .map(TimelineDetails::Ready)
-                    .unwrap_or(TimelineDetails::Unavailable);
-
-                match TimelineAction::from_event(
-                    any_sync_timeline_event,
-                    &raw_any_sync_timeline_event,
-                    room,
-                    None,
-                    None,
-                    None,
-                    None,
-                )
-                .await
-                {
-                    // Easy path: no aggregation, direct event.
-                    Some(TimelineAction::AddItem { content }) => {
-                        Self::Remote { timestamp, sender, is_own, profile, content }
-                    }
-
-                    // Aggregated event.
-                    //
-                    // Only edits are supported for the moment.
-                    Some(TimelineAction::HandleAggregation {
-                        kind:
-                            HandleAggregationKind::Edit { replacement: Replacement { new_content, .. } },
-                        ..
-                    }) => {
-                        // Let's map the edit into a regular message.
-                        match TimelineAction::from_content(
-                            AnyMessageLikeEventContent::RoomMessage(RoomMessageEventContent::new(
-                                new_content.msgtype,
-                            )),
-                            // We don't care about the `InReplyToDetails` in the context of a
-                            // `LatestEventValue`.
-                            None,
-                            // We don't care about the thread information in the context of a
-                            // `LatestEventValue`.
-                            None,
-                            None,
-                        ) {
-                            // The expected case.
-                            TimelineAction::AddItem { content } => {
-                                Self::Remote { timestamp, sender, is_own, profile, content }
-                            }
-
-                            // Supposedly unreachable, but let's pretend there is no
-                            // `LatestEventValue` if it happens.
-                            _ => {
-                                trace!("latest event was an edit that failed to be un-aggregated");
-
-                                Self::None
-                            }
-                        }
-                    }
+                let profile =
+                    TimelineDetails::from_initial_value(Profile::load(room, &sender).await);
 
-                    _ => Self::None,
+                match TimelineItemContent::from_event(room, timeline_event).await {
+                    Some(content) => Self::Remote { timestamp, sender, is_own, profile, content },
+                    None => Self::None,
                 }
             }
             BaseLatestEventValue::RemoteInvite { timestamp, inviter, .. } => {
                 let inviter_profile = if let Some(inviter_id) = &inviter {
-                    room.profile_from_user_id(inviter_id)
-                        .await
-                        .map(TimelineDetails::Ready)
-                        .unwrap_or(TimelineDetails::Unavailable)
+                    TimelineDetails::from_initial_value(Profile::load(room, inviter_id).await)
                 } else {
                     TimelineDetails::Unavailable
                 };
@@ -199,11 +132,8 @@ impl LatestEventValue {
 
                 let sender =
                     client.user_id().expect("The `Client` is supposed to be logged").to_owned();
-                let profile = room
-                    .profile_from_user_id(&sender)
-                    .await
-                    .map(TimelineDetails::Ready)
-                    .unwrap_or(TimelineDetails::Unavailable);
+                let profile =
+                    TimelineDetails::from_initial_value(Profile::load(room, &sender).await);
 
                 match TimelineAction::from_content(message_like_event_content, None, None, None) {
                     TimelineAction::AddItem { content } => Self::Local {

crates/matrix-sdk-ui/src/timeline/thread_list_service.rs

@@ -28,20 +28,11 @@ use matrix_sdk::{
     task_monitor::BackgroundTaskHandle,
 };
 use matrix_sdk_common::serde_helpers::extract_thread_root;
-use ruma::{
-    MilliSecondsSinceUnixEpoch, OwnedEventId, OwnedUserId,
-    events::{
-        AnyMessageLikeEventContent, relation::Replacement, room::message::RoomMessageEventContent,
-    },
-};
+use ruma::{MilliSecondsSinceUnixEpoch, OwnedEventId, OwnedUserId};
 use tokio::sync::Mutex as AsyncMutex;
 use tracing::{error, trace, warn};
 
-use crate::timeline::{
-    Profile, TimelineDetails, TimelineItemContent,
-    event_handler::{HandleAggregationKind, TimelineAction},
-    traits::RoomDataProvider,
-};
+use crate::timeline::{Profile, TimelineDetails, TimelineItemContent, traits::RoomDataProvider};
 
 /// Each `ThreadListItem` represents one thread root event in the room. The
 /// fields are pre-resolved from the raw homeserver response: the sender's
@@ -379,53 +370,9 @@ impl ThreadListService {
         let timestamp = timeline_event.timestamp()?;
         let sender = timeline_event.sender()?;
         let is_own = room.own_user_id() == sender;
-
-        let raw = timeline_event.into_raw();
-        let deserialized = match raw.deserialize() {
-            Ok(ev) => ev,
-            Err(e) => {
-                error!("Failed deserializing thread event for latest_event: {e}");
-                return None;
-            }
-        };
-
-        let sender_profile = room
-            .profile_from_user_id(&sender)
-            .await
-            .map(TimelineDetails::Ready)
-            .unwrap_or(TimelineDetails::Unavailable);
-
-        let content: Option<TimelineItemContent> = match TimelineAction::from_event(
-            deserialized,
-            &raw,
-            room,
-            None,
-            None,
-            None,
-            None,
-        )
-        .await
-        {
-            Some(TimelineAction::AddItem { content }) => Some(content),
-            Some(TimelineAction::HandleAggregation {
-                kind: HandleAggregationKind::Edit { replacement: Replacement { new_content, .. } },
-                ..
-            }) => {
-                match TimelineAction::from_content(
-                    AnyMessageLikeEventContent::RoomMessage(RoomMessageEventContent::new(
-                        new_content.msgtype,
-                    )),
-                    None,
-                    None,
-                    None,
-                ) {
-                    TimelineAction::AddItem { content } => Some(content),
-                    _ => None,
-                }
-            }
-            _ => None,
-        };
-
+        let sender_profile =
+            TimelineDetails::from_initial_value(Profile::load(room, &sender).await);
+        let content = TimelineItemContent::from_event(room, timeline_event).await;
         Some(ThreadListItemEvent { event_id, timestamp, sender, is_own, sender_profile, content })
     }
 

crates/matrix-sdk-ui/src/timeline/traits.rs

@@ -164,19 +164,7 @@ impl RoomDataProvider for Room {
     }
 
     async fn profile_from_user_id<'a>(&'a self, user_id: &'a UserId) -> Option<Profile> {
-        match self.get_member_no_sync(user_id).await {
-            Ok(Some(member)) => Some(Profile {
-                display_name: member.display_name().map(ToOwned::to_owned),
-                display_name_ambiguous: member.name_ambiguous(),
-                avatar_url: member.avatar_url().map(ToOwned::to_owned),
-            }),
-            Ok(None) if self.are_members_synced() => Some(Profile::default()),
-            Ok(None) => None,
-            Err(e) => {
-                error!(%user_id, "Failed to fetch room member information: {e}");
-                None
-            }
-        }
+        Profile::load(self, user_id).await
     }
 
     async fn load_user_receipt<'a>(