matrix-rust-sdk

public

Star0

Fork 0

Watch0

22 commits 4 branches 0 tags 0 releases16.6 MiB

Commit `4a96f652bdcd`

tarball

atagen <boss@atagen.co>2026-10-25 08:58 UTC

3 files changed+154-34

timeline: repopulate read markers and recycle ids on a reset

The Reset arm cleared read_receipts and fully_read_event without loading them back the way an initial load does, so the read marker vanished after every history reset, and it discarded recycled_timeline_ids so every surviving row got a new unique id and re-rendered.

Modified file: crates/matrix-sdk-ui/src/timeline/controller/read_receipts.rs+59 additions−29 deletions@@ -777,9 +777,27 @@ impl<P: RoomDataProvider> TimelineState<P> {
         room_data_provider: &P,
         receipt_type: ReceiptType,
     ) {
+        self.meta
+            .populate_initial_user_receipt(
+                self.focus.receipt_thread(),
+                room_data_provider,
+                receipt_type,
+            )
+            .await;
+    }
+}
+
+impl TimelineMetadata {
+    /// Populates our own latest read receipt in the in-memory by-user read
+    /// receipt cache.
+    pub(super) async fn populate_initial_user_receipt<P: RoomDataProvider>(
+        &mut self,
+        receipt_thread: ReceiptThread,
+        room_data_provider: &P,
+        receipt_type: ReceiptType,
+    ) {
         let own_user_id = room_data_provider.own_user_id().to_owned();
 
-        let receipt_thread = self.focus.receipt_thread();
         let wants_unthreaded_receipts = receipt_thread == ReceiptThread::Unthreaded;
 
         let mut read_receipt = room_data_provider
@@ -794,10 +812,47 @@ impl<P: RoomDataProvider> TimelineState<P> {
         }
 
         if let Some(read_receipt) = read_receipt {
-            self.meta.read_receipts.upsert_latest(own_user_id, receipt_type, read_receipt);
+            self.read_receipts.upsert_latest(own_user_id, receipt_type, read_receipt);
         }
     }
 
+    /// Get the ID of the visible timeline event with the latest read receipt
+    /// for the given user.
+    pub(super) fn latest_user_read_receipt_timeline_event_id(
+        &self,
+        user_id: &UserId,
+        all_remote_events: &AllRemoteEvents,
+    ) -> Option<OwnedEventId> {
+        // We only need to use the local map, since receipts for known events are
+        // already loaded from the store.
+        let public_read_receipt = self.read_receipts.get_latest(user_id, &ReceiptType::Read);
+        let private_read_receipt =
+            self.read_receipts.get_latest(user_id, &ReceiptType::ReadPrivate);
+
+        // Let's assume that a private read receipt should be more recent than a public
+        // read receipt, otherwise there's no point in the private read receipt,
+        // and use it as default.
+        let (latest_receipt_id, _) = match TimelineMetadata::compare_optional_receipts(
+            public_read_receipt,
+            private_read_receipt,
+            all_remote_events,
+        ) {
+            Ordering::Greater => public_read_receipt?,
+            Ordering::Less => private_read_receipt?,
+            _ => unreachable!(),
+        };
+
+        // Find the corresponding visible event.
+        all_remote_events
+            .iter()
+            .rev()
+            .skip_while(|ev| ev.event_id != *latest_receipt_id)
+            .find(|ev| ev.visible && ev.can_show_read_receipts)
+            .map(|ev| ev.event_id.clone())
+    }
+}
+
+impl<P: RoomDataProvider> TimelineState<P> {
     /// Get the latest read receipt for the given user.
     ///
     /// Useful to get the latest read receipt, whether it's private or public.
@@ -851,33 +906,8 @@ impl<P: RoomDataProvider> TimelineState<P> {
         &self,
         user_id: &UserId,
     ) -> Option<OwnedEventId> {
-        // We only need to use the local map, since receipts for known events are
-        // already loaded from the store.
-        let public_read_receipt = self.meta.read_receipts.get_latest(user_id, &ReceiptType::Read);
-        let private_read_receipt =
-            self.meta.read_receipts.get_latest(user_id, &ReceiptType::ReadPrivate);
-
-        // Let's assume that a private read receipt should be more recent than a public
-        // read receipt, otherwise there's no point in the private read receipt,
-        // and use it as default.
-        let (latest_receipt_id, _) = match TimelineMetadata::compare_optional_receipts(
-            public_read_receipt,
-            private_read_receipt,
-            self.items.all_remote_events(),
-        ) {
-            Ordering::Greater => public_read_receipt?,
-            Ordering::Less => private_read_receipt?,
-            _ => unreachable!(),
-        };
-
-        // Find the corresponding visible event.
-        self.items
-            .all_remote_events()
-            .iter()
-            .rev()
-            .skip_while(|ev| ev.event_id != *latest_receipt_id)
-            .find(|ev| ev.visible && ev.can_show_read_receipts)
-            .map(|ev| ev.event_id.clone())
+        self.meta
+            .latest_user_read_receipt_timeline_event_id(user_id, self.items.all_remote_events())
     }
 }
 

Modified file: crates/matrix-sdk-ui/src/timeline/controller/state_transaction.rs+36 additions−2 deletions@@ -214,9 +214,31 @@ impl<'a, P: RoomDataProvider> TimelineStateTransaction<'a, P> {
                 }
 
                 VectorDiff::Reset { values: events } => {
-                    recycled_timeline_ids.clear();
+                    for event_meta in self.items.all_remote_events().iter() {
+                        if let Some(index) = event_meta.timeline_item_index {
+                            recycled_timeline_ids.insert(
+                                event_meta.event_id.clone(),
+                                self.items[index].unique_id().clone(),
+                            );
+                        }
+                    }
                     self.clear();
+                    let track_read_receipts = settings.track_read_receipts.is_enabled();
+                    if track_read_receipts {
+                        for receipt_type in [ReceiptType::Read, ReceiptType::ReadPrivate] {
+                            self.meta
+                                .populate_initial_user_receipt(
+                                    self.focus.receipt_thread(),
+                                    room_data_provider,
+                                    receipt_type,
+                                )
+                                .await;
+                        }
+                    }
                     for event in events {
+                        let recycled_timeline_id = event
+                            .event_id()
+                            .and_then(|event_id| recycled_timeline_ids.remove(&event_id));
                         self.handle_remote_event(
                             event,
                             TimelineItemPosition::End { origin },
@@ -224,10 +246,22 @@ impl<'a, P: RoomDataProvider> TimelineStateTransaction<'a, P> {
                             settings,
                             &mut date_divider_adjuster,
                             &mut cached_profiles,
-                            None,
+                            recycled_timeline_id,
                         )
                         .await;
                     }
+                    if track_read_receipts {
+                        let fully_read = match room_data_provider.load_fully_read_marker().await {
+                            Some(fully_read) => Some(fully_read),
+                            None => self.meta.latest_user_read_receipt_timeline_event_id(
+                                room_data_provider.own_user_id(),
+                                self.items.all_remote_events(),
+                            ),
+                        };
+                        if let Some(fully_read) = fully_read {
+                            self.set_fully_read_event(fully_read);
+                        }
+                    }
                 }
 
                 v => unimplemented!("{v:?}"),

Modified file: crates/matrix-sdk-ui/src/timeline/tests/segmented_history.rs+59 additions−3 deletions@@ -2,14 +2,17 @@ use eyeball_im::VectorDiff;
 use futures_util::{FutureExt, StreamExt};
 use imbl::vector;
 use matrix_sdk::event_cache::{HistoryGap, HistoryGapPosition, HistoryGapStatus};
-use matrix_sdk_test::{ALICE, async_test};
+use matrix_sdk_test::{ALICE, BOB, async_test};
 use ruma::{
     TransactionId, event_id,
     events::{AnyMessageLikeEventContent, room::message::RoomMessageEventContent},
 };
 
-use super::TestTimeline;
-use crate::timeline::{VirtualTimelineItem, event_item::RemoteEventOrigin};
+use super::{TestRoomDataProvider, TestTimeline, TestTimelineBuilder};
+use crate::timeline::{
+    TimelineReadReceiptTracking, VirtualTimelineItem, controller::TimelineSettings,
+    event_item::RemoteEventOrigin,
+};
 
 #[async_test]
 async fn test_segmented_history_initial_snapshot_keeps_retained_side() {
@@ -226,3 +229,56 @@ async fn test_segmented_history_reset_preserves_pending_sends() {
         1
     );
 }
+
+#[async_test]
+async fn test_history_reset_keeps_read_marker_and_item_identities() {
+    let old = event_id!("$old");
+    let new = event_id!("$new");
+    let timeline = TestTimelineBuilder::new()
+        .provider(TestRoomDataProvider::default().with_fully_read_marker(old.to_owned()))
+        .settings(TimelineSettings {
+            track_read_receipts: TimelineReadReceiptTracking::AllEvents,
+            ..Default::default()
+        })
+        .build();
+    let f = &timeline.factory;
+    timeline
+        .controller
+        .replace_with_initial_remote_events(
+            [
+                f.text_msg("old").sender(*ALICE).event_id(old).into_event(),
+                f.text_msg("new").sender(*BOB).event_id(new).into_event(),
+            ],
+            RemoteEventOrigin::Cache,
+        )
+        .await;
+    let unique_id = |items: &imbl::Vector<std::sync::Arc<crate::timeline::TimelineItem>>| {
+        items
+            .iter()
+            .find(|item| item.as_event().and_then(|event| event.event_id()) == Some(new))
+            .unwrap()
+            .unique_id()
+            .clone()
+    };
+    let before = unique_id(&timeline.controller.items().await);
+
+    timeline
+        .controller
+        .handle_history_update(
+            vec![VectorDiff::Reset {
+                values: vector![
+                    f.text_msg("old").sender(*ALICE).event_id(old).into(),
+                    f.text_msg("new").sender(*BOB).event_id(new).into(),
+                ],
+            }],
+            None,
+            RemoteEventOrigin::Cache,
+        )
+        .await;
+
+    let items = timeline.controller.items().await;
+    assert_eq!(unique_id(&items), before);
+    assert!(
+        items.iter().any(|item| matches!(item.as_virtual(), Some(VirtualTimelineItem::ReadMarker)))
+    );
+}

matrix-rust-sdk

Commit 4a96f652bdcd

Commit `4a96f652bdcd`