feat(timeline): indicate when the replied-to event is not a standalone item

If the replied-to event is an aggregation, the
`RepliedToEvent::try_from_timeline_event` will now return `Ok(None)`,
and the caller may handle this as they please.

In the FFI layer, this will be filled with an error message indicating
that the event is unsupported.

Author: bnjbvr

bindings/matrix-sdk-ffi/src/timeline/mod.rs

@@ -687,7 +687,7 @@ impl Timeline {
         };
 
         match replied_to {
-            Ok(replied_to) => Ok(Arc::new(InReplyToDetails::new(
+            Ok(Some(replied_to)) => Ok(Arc::new(InReplyToDetails::new(
                 event_id_str,
                 RepliedToEventDetails::Ready {
                     content: replied_to.content().clone().into(),
@@ -696,6 +696,11 @@ impl Timeline {
                 },
             ))),
 
+            Ok(None) => Ok(Arc::new(InReplyToDetails::new(
+                event_id_str,
+                RepliedToEventDetails::Error { message: "unsupported event".to_owned() },
+            ))),
+
             Err(e) => Ok(Arc::new(InReplyToDetails::new(
                 event_id_str,
                 RepliedToEventDetails::Error { message: e.to_string() },

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

@@ -1336,10 +1336,15 @@ impl<P: RoomDataProvider, D: Decryptor> TimelineController<P, D> {
         txn.commit();
     }
 
+    /// Create a [`RepliedToEvent`] from an arbitrary event, be it in the
+    /// timeline or not.
+    ///
+    /// Can be `None` if the event cannot be represented as a standalone item,
+    /// because it's an aggregation.
     pub(super) async fn make_replied_to(
         &self,
         event: TimelineEvent,
-    ) -> Result<RepliedToEvent, Error> {
+    ) -> Result<Option<RepliedToEvent>, Error> {
         // Reborrow, to avoid that the automatic deref borrows the entire guard (and we
         // can't borrow both items and meta).
         let state = &mut *self.state.write().await;
@@ -1581,17 +1586,25 @@ async fn fetch_replied_to_event(
     let res = match room.load_or_fetch_event(in_reply_to, None).await {
         Ok(timeline_event) => {
             let state = &mut *state_lock.write().await;
-            TimelineDetails::Ready(Box::new(
-                RepliedToEvent::try_from_timeline_event(
-                    timeline_event,
-                    room,
-                    &state.items,
-                    &mut state.meta,
-                )
-                .await?,
-            ))
+
+            let replied_to_item = RepliedToEvent::try_from_timeline_event(
+                timeline_event,
+                room,
+                &state.items,
+                &mut state.meta,
+            )
+            .await?;
+
+            if let Some(item) = replied_to_item {
+                TimelineDetails::Ready(Box::new(item))
+            } else {
+                // The replied-to item is an aggregation, not a standalone item.
+                return Err(Error::UnsupportedEvent);
+            }
         }
+
         Err(e) => TimelineDetails::Error(Arc::new(e)),
     };
+
     Ok(res)
 }

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

@@ -23,7 +23,7 @@ use super::TimelineItemContent;
 use crate::timeline::{
     controller::TimelineMetadata,
     event_handler::TimelineAction,
-    event_item::{content::MsgLikeContent, EventTimelineItem, Profile, TimelineDetails},
+    event_item::{EventTimelineItem, Profile, TimelineDetails},
     traits::RoomDataProvider,
     Error as TimelineError, TimelineItem,
 };
@@ -97,7 +97,7 @@ impl RepliedToEvent {
         room_data_provider: &P,
         timeline_items: &Vector<Arc<TimelineItem>>,
         meta: &mut TimelineMetadata,
-    ) -> Result<Self, TimelineError> {
+    ) -> Result<Option<Self>, TimelineError> {
         let (raw_event, unable_to_decrypt_info) = match timeline_event.kind {
             matrix_sdk::deserialized_responses::TimelineEventKind::UnableToDecrypt {
                 utd_info,
@@ -127,17 +127,15 @@ impl RepliedToEvent {
         )
         .await;
 
-        let content = if let Some(TimelineAction::AddItem { content, .. }) = action {
-            content
-        } else {
-            // TODO: need some kind of "unsupported" event here: return an option
-            TimelineItemContent::MsgLike(MsgLikeContent::redacted())
+        let Some(TimelineAction::AddItem { content }) = action else {
+            // The event can't be represented as a standalone timeline item.
+            return Ok(None);
         };
 
         let sender_profile = TimelineDetails::from_initial_value(
             room_data_provider.profile_from_user_id(&sender).await,
         );
 
-        Ok(Self { content, sender, sender_profile })
+        Ok(Some(Self { content, sender, sender_profile }))
     }
 }

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

@@ -691,7 +691,13 @@ impl Timeline {
 
     /// Create a [`RepliedToEvent`] from an arbitrary event, be it in the
     /// timeline or not.
-    pub async fn make_replied_to(&self, event: TimelineEvent) -> Result<RepliedToEvent, Error> {
+    ///
+    /// Can be `None` if the event cannot be represented as a standalone item,
+    /// because it's an aggregation.
+    pub async fn make_replied_to(
+        &self,
+        event: TimelineEvent,
+    ) -> Result<Option<RepliedToEvent>, Error> {
         self.controller.make_replied_to(event).await
     }
 }