chore: Upgrade matrix-sdk crate

And run `cargo update`.

Cargo.toml

@@ -67,7 +67,7 @@ sourceview = { package = "sourceview5", version = "0.9" }
 
 [dependencies.matrix-sdk]
 git = "https://github.com/matrix-org/matrix-rust-sdk.git"
-rev = "92b4c2a469f507696fa9db3d6bdb000a761e2694"
+rev = "7f4e79e2a3bb07fa189c62987a06b3f78f2e4286"
 features = [
     "socks",
     "sso-login",
@@ -77,14 +77,14 @@ features = [
 
 [dependencies.matrix-sdk-ui]
 git = "https://github.com/matrix-org/matrix-rust-sdk.git"
-rev = "92b4c2a469f507696fa9db3d6bdb000a761e2694"
+rev = "7f4e79e2a3bb07fa189c62987a06b3f78f2e4286"
 default-features = false
 features = ["e2e-encryption", "native-tls"]
 
 [dependencies.ruma]
 # version = "0.10"
 git = "https://github.com/matrix-org/ruma.git"
-rev = "4d3d8b46fd519012e4585ccf00dbea1eb602c028"
+rev = "17f6e555528512319e706bb2cfe68a12ec5603b6"
 features = [
     "unstable-unspecified",
     "client-api-c",

src/session/model/room/event/mod.rs

@@ -22,7 +22,10 @@ use tracing::error;
 mod reaction_group;
 mod reaction_list;
 
-pub use self::{reaction_group::ReactionGroup, reaction_list::ReactionList};
+pub use self::{
+    reaction_group::{ReactionData, ReactionGroup},
+    reaction_list::ReactionList,
+};
 use super::{
     timeline::{TimelineItem, TimelineItemImpl},
     Member, Room,
@@ -144,6 +147,9 @@ mod imp {
         /// server, as a string.
         #[property(get = Self::event_id_string)]
         pub event_id_string: PhantomData<Option<String>>,
+        /// The ID of this `Event` in the SDK timeline.
+        #[property(get = Self::timeline_id, type = String)]
+        pub timeline_id: RefCell<Option<String>>,
         /// The ID of the sender of this `Event`, as a string.
         #[property(get = Self::sender_id_string)]
         pub sender_id_string: PhantomData<String>,
@@ -188,6 +194,7 @@ mod imp {
                 source: Default::default(),
                 has_source: Default::default(),
                 event_id_string: Default::default(),
+                timeline_id: Default::default(),
                 sender_id_string: Default::default(),
                 timestamp: Default::default(),
                 timestamp_full: Default::default(),
@@ -238,7 +245,7 @@ mod imp {
 
     impl Event {
         /// Set the underlying SDK timeline item of this `Event`.
-        pub fn set_item(&self, item: EventTimelineItem) {
+        pub fn set_item(&self, item: EventTimelineItem, timeline_id: &str) {
             let obj = self.obj();
 
             let prev_raw = self.raw();
@@ -252,6 +259,7 @@ mod imp {
             obj.update_read_receipts(item.read_receipts());
 
             self.item.replace(Some(item));
+            self.timeline_id.replace(Some(timeline_id.to_owned()));
 
             if !raw_eq(prev_raw.as_ref(), self.raw().as_ref()) {
                 obj.notify_source();
@@ -280,6 +288,7 @@ mod imp {
 
             obj.update_state();
             obj.emit_by_name::<()>("item-changed", &[]);
+            obj.notify_timeline_id();
         }
 
         /// The raw JSON source for this `Event`, if it has been echoed back
@@ -316,6 +325,14 @@ mod imp {
                 .map(ToString::to_string)
         }
 
+        /// The ID of this `Event` in the SDK timeline.
+        fn timeline_id(&self) -> String {
+            self.timeline_id
+                .borrow()
+                .clone()
+                .expect("event should always have timeline ID after construction")
+        }
+
         /// The ID of the sender of this `Event`, as a string.
         fn sender_id_string(&self) -> String {
             self.item
@@ -446,12 +463,12 @@ glib::wrapper! {
 
 impl Event {
     /// Create a new `Event` with the given SDK timeline item.
-    pub fn new(item: EventTimelineItem, room: &Room) -> Self {
+    pub fn new(item: EventTimelineItem, timeline_id: &str, room: &Room) -> Self {
         let obj = glib::Object::builder::<Self>()
             .property("room", room)
             .build();
 
-        obj.imp().set_item(item);
+        obj.imp().set_item(item, timeline_id);
 
         obj
     }
@@ -459,18 +476,18 @@ impl Event {
     /// Try to update this `Event` with the given SDK timeline item.
     ///
     /// Returns `true` if the update succeeded.
-    pub fn try_update_with(&self, item: &EventTimelineItem) -> bool {
+    pub fn try_update_with(&self, item: &EventTimelineItem, timeline_id: &str) -> bool {
         match &self.key() {
             EventKey::TransactionId(txn_id)
                 if item.is_local_echo() && item.transaction_id() == Some(txn_id) =>
             {
-                self.imp().set_item(item.clone());
+                self.imp().set_item(item.clone(), timeline_id);
                 return true;
             }
             EventKey::EventId(event_id)
                 if !item.is_local_echo() && item.event_id() == Some(event_id) =>
             {
-                self.imp().set_item(item.clone());
+                self.imp().set_item(item.clone(), timeline_id);
                 return true;
             }
             _ => {}

src/session/model/room/event/reaction_group.rs

@@ -1,9 +1,22 @@
 use gtk::{gio, glib, prelude::*, subclass::prelude::*};
-use matrix_sdk_ui::timeline::ReactionGroup as SdkReactionGroup;
+use indexmap::IndexMap;
+use matrix_sdk_ui::timeline::ReactionInfo;
+use ruma::{MilliSecondsSinceUnixEpoch, OwnedUserId};
 
-use super::EventKey;
 use crate::{prelude::*, session::model::User};
 
+/// A map of user ID to reaction info.
+type ReactionsMap = IndexMap<OwnedUserId, ReactionInfo>;
+
+/// Data of a reaction in a reaction group.
+#[derive(Clone, Debug)]
+pub struct ReactionData {
+    /// The sender of the reaction.
+    pub sender_id: OwnedUserId,
+    /// The timestamp of the reaction.
+    pub timestamp: MilliSecondsSinceUnixEpoch,
+}
+
 mod imp {
     use std::{
         cell::{OnceCell, RefCell},
@@ -22,7 +35,7 @@ mod imp {
         #[property(get, construct_only)]
         pub key: OnceCell<String>,
         /// The reactions in the group.
-        pub reactions: RefCell<Option<SdkReactionGroup>>,
+        pub reactions: RefCell<Option<ReactionsMap>>,
         /// The number of reactions in this group.
         #[property(get = Self::count)]
         pub count: PhantomData<u32>,
@@ -50,17 +63,22 @@ mod imp {
             self.reactions
                 .borrow()
                 .as_ref()
-                .map(|reactions| reactions.senders().count())
+                .map(|reactions| reactions.len())
                 .unwrap_or_default() as u32
         }
 
         fn item(&self, position: u32) -> Option<glib::Object> {
-            self.reactions.borrow().as_ref().and_then(|reactions| {
+            self.reactions
-                reactions
+                .borrow()
-                    .senders()
+                .as_ref()
-                    .nth(position as usize)
+                .and_then(|reactions| reactions.get_index(position as usize))
-                    .map(|sd| glib::BoxedAnyObject::new(sd.clone()).upcast())
+                .map(|(user_id, info)| {
-            })
+                    glib::BoxedAnyObject::new(ReactionData {
+                        sender_id: user_id.clone(),
+                        timestamp: info.timestamp,
+                    })
+                    .upcast()
+                })
         }
     }
 
@@ -76,8 +94,7 @@ mod imp {
             self.reactions
                 .borrow()
                 .as_ref()
-                .filter(|reactions| reactions.by_sender(user_id).next().is_some())
+                .is_some_and(|reactions| reactions.contains_key(user_id))
-                .is_some()
         }
     }
 }
@@ -96,42 +113,20 @@ impl ReactionGroup {
             .build()
     }
 
-    /// The event ID of the reaction in this group sent by the logged-in user,
-    /// if any.
-    pub fn user_reaction_event_key(&self) -> Option<EventKey> {
-        let user = self.user();
-        let user_id = user.user_id();
-
-        self.imp()
-            .reactions
-            .borrow()
-            .as_ref()
-            .and_then(|reactions| {
-                reactions
-                    .by_sender(user_id)
-                    .next()
-                    .and_then(|timeline_key| match timeline_key {
-                        (Some(txn_id), None) => Some(EventKey::TransactionId(txn_id.clone())),
-                        (_, Some(event_id)) => Some(EventKey::EventId(event_id.clone())),
-                        _ => None,
-                    })
-            })
-    }
-
     /// Update this group with the given reactions.
-    pub fn update(&self, new_reactions: SdkReactionGroup) {
+    pub fn update(&self, new_reactions: &ReactionsMap) {
         let prev_has_user = self.has_user();
         let prev_count = self.count();
-        let new_count = new_reactions.senders().count() as u32;
+        let new_count = new_reactions.len() as u32;
         let reactions = &self.imp().reactions;
 
         let same_reactions = match reactions.borrow().as_ref() {
             Some(old_reactions) => {
                 prev_count == new_count
-                    && new_reactions.senders().zip(old_reactions.senders()).all(
+                    && new_reactions.iter().zip(old_reactions.iter()).all(
-                        |(old_sender, new_sender)| {
+                        |((old_sender_id, old_info), (new_sender_id, new_info))| {
-                            old_sender.sender_id == new_sender.sender_id
+                            old_sender_id == new_sender_id
-                                && old_sender.timestamp == new_sender.timestamp
+                                && old_info.timestamp == new_info.timestamp
                         },
                     )
             }
@@ -142,7 +137,7 @@ impl ReactionGroup {
             return;
         }
 
-        *reactions.borrow_mut() = Some(new_reactions);
+        *reactions.borrow_mut() = Some(new_reactions.clone());
 
         self.items_changed(0, prev_count, new_count);
 

src/session/model/room/event/reaction_list.rs

@@ -1,5 +1,5 @@
 use gtk::{gio, glib, prelude::*, subclass::prelude::*};
-use matrix_sdk_ui::timeline::BundledReactions;
+use matrix_sdk_ui::timeline::ReactionsByKeyBySender;
 
 use super::ReactionGroup;
 use crate::session::model::User;
@@ -72,7 +72,7 @@ impl ReactionList {
     }
 
     /// Update the reaction list with the given reactions.
-    pub fn update(&self, new_reactions: BundledReactions) {
+    pub fn update(&self, new_reactions: ReactionsByKeyBySender) {
         let reactions = &self.imp().reactions;
 
         let changed = {
@@ -92,11 +92,11 @@ impl ReactionList {
             let new_len = new_reactions.len();
 
             *reactions = new_reactions
-                .into_iter()
+                .iter()
                 .map(|(key, reactions)| {
-                    let group = ReactionGroup::new(&key, user);
+                    let group = ReactionGroup::new(key, user);
                     group.update(reactions);
-                    (key, group)
+                    (key.clone(), group)
                 })
                 .collect();
 
@@ -107,7 +107,7 @@ impl ReactionList {
             self.items_changed(0, prev_len as u32, new_len as u32);
         } else {
             let reactions = reactions.borrow();
-            for (reactions, group) in new_reactions.into_values().zip(reactions.values()) {
+            for (reactions, group) in new_reactions.values().zip(reactions.values()) {
                 group.update(reactions);
             }
         }

src/session/model/room/mod.rs

@@ -22,7 +22,6 @@ use ruma::{
     api::client::error::{ErrorKind, RetryAfter},
     events::{
         receipt::{ReceiptEventContent, ReceiptType},
-        relation::Annotation,
         room::{
             avatar::RoomAvatarEventContent, encryption::SyncRoomEncryptionEvent,
             guest_access::GuestAccess, history_visibility::HistoryVisibility,
@@ -1527,12 +1526,13 @@ impl Room {
         self.notify_latest_activity();
     }
 
-    /// Toggle a `key` reaction for the `relates_to` event ID in this room.
+    /// Toggle the `key` reaction on the given related event in this room.
-    pub async fn toggle_reaction(&self, key: String, relates_to: OwnedEventId) -> Result<(), ()> {
+    pub async fn toggle_reaction(&self, key: String, event: &Event) -> Result<(), ()> {
         let timeline = self.timeline().matrix_timeline();
-        let annotation = Annotation::new(relates_to, key);
+        let event_timeline_id = event.timeline_id();
 
-        let handle = spawn_tokio!(async move { timeline.toggle_reaction(&annotation).await });
+        let handle =
+            spawn_tokio!(async move { timeline.toggle_reaction(&event_timeline_id, &key).await });
 
         if let Err(error) = handle.await.unwrap() {
             error!("Could not toggle reaction: {error}");

src/session/model/room/timeline/mod.rs

@@ -523,7 +523,8 @@ impl Timeline {
             };
             let matrix_room = room.matrix_room().clone();
             let event_id_clone = event_id.clone();
-            let handle = spawn_tokio!(async move { matrix_room.event(&event_id_clone).await });
+            let handle =
+                spawn_tokio!(async move { matrix_room.event(&event_id_clone, None).await });
             match handle.await.unwrap() {
                 Ok(room_event) => room_event.event.deserialize_as().map_err(Into::into),
                 Err(error) => {

src/session/model/room/timeline/timeline_item.rs

@@ -136,7 +136,9 @@ impl TimelineItem {
     /// Constructs the proper child type.
     pub fn new(item: &SdkTimelineItem, room: &Room) -> Self {
         match item.kind() {
-            TimelineItemKind::Event(event) => Event::new(event.clone(), room).upcast(),
+            TimelineItemKind::Event(event) => {
+                Event::new(event.clone(), item.unique_id(), room).upcast()
+            }
             TimelineItemKind::Virtual(item) => VirtualItem::new(item).upcast(),
         }
     }
@@ -148,7 +150,7 @@ impl TimelineItem {
         match item.kind() {
             TimelineItemKind::Event(new_event) => {
                 if let Some(event) = self.downcast_ref::<Event>() {
-                    return event.try_update_with(new_event);
+                    return event.try_update_with(new_event, item.unique_id());
                 }
             }
             TimelineItemKind::Virtual(_item) => {

src/session/view/content/room_history/item_row.rs

@@ -907,11 +907,8 @@ impl ItemRow {
         let Some(event) = self.item().and_downcast::<Event>() else {
             return;
         };
-        let Some(event_id) = event.event_id() else {
-            return;
-        };
 
-        if event.room().toggle_reaction(key, event_id).await.is_err() {
+        if event.room().toggle_reaction(key, &event).await.is_err() {
             toast!(self, gettext("Could not toggle reaction"));
         }
     }

src/session/view/content/room_history/message_row/reaction/mod.rs

@@ -1,6 +1,5 @@
 use adw::subclass::prelude::*;
 use gtk::{gio, glib, glib::clone, prelude::*, CompositeTemplate};
-use matrix_sdk_ui::timeline::ReactionSenderData as SdkReactionSenderData;
 
 mod reaction_popover;
 
@@ -9,7 +8,7 @@ use crate::{
     gettext_f, ngettext_f,
     prelude::*,
     session::{
-        model::{Member, MemberList, ReactionGroup},
+        model::{Member, MemberList, ReactionData, ReactionGroup},
         view::content::room_history::member_timestamp::MemberTimestamp,
     },
     utils::{BoundObjectWeakRef, EMOJI_REGEX},
@@ -165,9 +164,9 @@ impl MessageReaction {
                 break;
             };
 
-            let sender_data = boxed.borrow::<SdkReactionSenderData>();
+            let reaction_data = boxed.borrow::<ReactionData>();
-            let member = members.get_or_create(sender_data.sender_id.clone());
+            let member = members.get_or_create(reaction_data.sender_id.clone());
-            let timestamp = sender_data.timestamp.as_secs().into();
+            let timestamp = reaction_data.timestamp.as_secs().into();
             let sender = MemberTimestamp::new(&member, Some(timestamp));
 
             new_senders.push(sender);