fix(ui): Sending read receipt in live timeline when latest event is in a thread

Previously, this used the latest event in the thread as the event to mark as read, while this is not right if we're in a context that hides thread events

Author: jmartinesp

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

@@ -577,10 +577,16 @@ pub(in crate::timeline) struct EventMeta {
     /// Note that the #2 timeline item (the day divider) doesn't map to any
     /// remote event, but if it moves, it has an impact on this mapping.
     pub timeline_item_index: Option<usize>,
+
+    pub thread_root_id: Option<OwnedEventId>,
 }
 
 impl EventMeta {
-    pub fn new(event_id: OwnedEventId, visible: bool) -> Self {
-        Self { event_id, visible, timeline_item_index: None }
+    pub fn new(
+        event_id: OwnedEventId,
+        visible: bool,
+        thread_root_id: Option<OwnedEventId>,
+    ) -> Self {
+        Self { event_id, visible, timeline_item_index: None, thread_root_id }
     }
 }

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

@@ -1761,7 +1761,27 @@ impl TimelineController {
     /// it's folded into another timeline item.
     pub(crate) async fn latest_event_id(&self) -> Option<OwnedEventId> {
         let state = self.state.read().await;
-        state.items.all_remote_events().last().map(|event_meta| &event_meta.event_id).cloned()
+        let filter_out_thread_events = match self.focus() {
+            TimelineFocusKind::Thread { .. } => false,
+            TimelineFocusKind::Live { hide_threaded_events } => hide_threaded_events.to_owned(),
+            TimelineFocusKind::Event { paginator } => {
+                paginator.get().is_some_and(|paginator| paginator.hide_threaded_events())
+            }
+            _ => true,
+        };
+        state
+            .items
+            .all_remote_events()
+            .iter()
+            .rev()
+            .filter_map(|item| {
+                if !filter_out_thread_events || item.thread_root_id.is_none() {
+                    Some(item.event_id.clone())
+                } else {
+                    None
+                }
+            })
+            .next()
     }
 
     #[instrument(skip(self), fields(room_id = ?self.room().room_id()))]

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

@@ -796,7 +796,12 @@ mod observable_items_tests {
     }
 
     fn event_meta(event_id: &str) -> EventMeta {
-        EventMeta { event_id: event_id.parse().unwrap(), timeline_item_index: None, visible: false }
+        EventMeta {
+            event_id: event_id.parse().unwrap(),
+            timeline_item_index: None,
+            visible: false,
+            thread_root_id: None,
+        }
     }
 
     macro_rules! assert_event_id {
@@ -1922,11 +1927,6 @@ impl AllRemoteEvents {
         Some(event_meta)
     }
 
-    /// Return a reference to the last remote event if it exists.
-    pub fn last(&self) -> Option<&EventMeta> {
-        self.0.back()
-    }
-
     /// Return the index of the last remote event if it exists.
     pub fn last_index(&self) -> Option<usize> {
         self.0.len().checked_sub(1)
@@ -2054,7 +2054,12 @@ mod all_remote_events_tests {
     use super::{AllRemoteEvents, EventMeta};
 
     fn event_meta(event_id: &str, timeline_item_index: Option<usize>) -> EventMeta {
-        EventMeta { event_id: event_id.parse().unwrap(), timeline_item_index, visible: false }
+        EventMeta {
+            event_id: event_id.parse().unwrap(),
+            timeline_item_index,
+            visible: false,
+            thread_root_id: None,
+        }
     }
 
     macro_rules! assert_events {

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

@@ -476,6 +476,7 @@ impl<'a, P: RoomDataProvider> TimelineStateTransaction<'a, P> {
         MilliSecondsSinceUnixEpoch,
         Option<OwnedTransactionId>,
         Option<TimelineAction>,
+        Option<OwnedEventId>,
         bool,
     )> {
         let state_key: Option<String> = raw.get_field("state_key").ok().flatten();
@@ -534,6 +535,7 @@ impl<'a, P: RoomDataProvider> TimelineStateTransaction<'a, P> {
                     origin_server_ts,
                     transaction_id,
                     Some(TimelineAction::failed_to_parse(event_type, deserialization_error)),
+                    None,
                     true,
                 ))
             }
@@ -550,7 +552,7 @@ impl<'a, P: RoomDataProvider> TimelineStateTransaction<'a, P> {
                 // Remember the event before returning prematurely.
                 // See [`ObservableItems::all_remote_events`].
                 self.add_or_update_remote_event(
-                    EventMeta::new(event_id, false),
+                    EventMeta::new(event_id, false, None),
                     sender.as_deref(),
                     origin_server_ts,
                     position,
@@ -628,63 +630,65 @@ impl<'a, P: RoomDataProvider> TimelineStateTransaction<'a, P> {
             _ => (event.kind.into_raw(), None),
         };
 
-        let (event_id, sender, timestamp, txn_id, timeline_action, should_add) = match raw
-            .deserialize()
-        {
-            // Classical path: the event is valid, can be deserialized, everything is alright.
-            Ok(event) => {
-                let (in_reply_to, thread_root) = self.meta.process_event_relations(
-                    &event,
-                    &raw,
-                    bundled_edit_encryption_info,
-                    &self.items,
-                    self.focus.is_thread(),
-                );
-
-                let should_add = self.should_add_event_item(
-                    room_data_provider,
-                    settings,
-                    &event,
-                    thread_root.as_deref(),
-                    position,
-                );
-
-                (
-                    event.event_id().to_owned(),
-                    event.sender().to_owned(),
-                    event.origin_server_ts(),
-                    event.transaction_id().map(ToOwned::to_owned),
-                    TimelineAction::from_event(
-                        event,
+        let (event_id, sender, timestamp, txn_id, timeline_action, thread_root, should_add) =
+            match raw.deserialize() {
+                // Classical path: the event is valid, can be deserialized, everything is alright.
+                Ok(event) => {
+                    let (in_reply_to, thread_root) = self.meta.process_event_relations(
+                        &event,
                         &raw,
+                        bundled_edit_encryption_info,
+                        &self.items,
+                        self.focus.is_thread(),
+                    );
+
+                    let should_add = self.should_add_event_item(
                         room_data_provider,
-                        utd_info
-                            .map(|utd_info| (utd_info, self.meta.unable_to_decrypt_hook.as_ref())),
-                        in_reply_to,
+                        settings,
+                        &event,
+                        thread_root.as_deref(),
+                        position,
+                    );
+
+                    (
+                        event.event_id().to_owned(),
+                        event.sender().to_owned(),
+                        event.origin_server_ts(),
+                        event.transaction_id().map(ToOwned::to_owned),
+                        TimelineAction::from_event(
+                            event,
+                            &raw,
+                            room_data_provider,
+                            utd_info.map(|utd_info| {
+                                (utd_info, self.meta.unable_to_decrypt_hook.as_ref())
+                            }),
+                            in_reply_to,
+                            thread_root.clone(),
+                            thread_summary,
+                        )
+                        .await,
                         thread_root,
-                        thread_summary,
+                        should_add,
                     )
-                    .await,
-                    should_add,
-                )
-            }
+                }
 
-            // The event seems invalid…
-            Err(e) => {
-                if let Some(tuple) =
-                    self.maybe_add_error_item(position, room_data_provider, &raw, e, settings).await
-                {
-                    tuple
-                } else {
-                    return false;
+                // The event seems invalid…
+                Err(e) => {
+                    if let Some(tuple) = self
+                        .maybe_add_error_item(position, room_data_provider, &raw, e, settings)
+                        .await
+                    {
+                        tuple
+                    } else {
+                        return false;
+                    }
                 }
-            }
-        };
+            };
 
         // Remember the event.
         // See [`ObservableItems::all_remote_events`].
         self.add_or_update_remote_event(
-            EventMeta::new(event_id.clone(), should_add),
+            EventMeta::new(event_id.clone(), should_add, thread_root),
             Some(&sender),
             Some(timestamp),
             position,