feat(ui): Add function to toggle reactions from timeline

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

@@ -198,6 +198,7 @@ impl TimelineBuilder {
                 event_handler_handles: handles,
                 room_update_join_handle,
             }),
+            reaction_lock: Mutex::new(()),
         };
 
         #[cfg(feature = "e2e-encryption")]

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

@@ -77,7 +77,7 @@ pub(super) struct TimelineEventMetadata {
     pub(super) is_highlighted: bool,
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub(super) enum TimelineEventKind {
     Message {
         content: AnyMessageLikeEventContent,
@@ -516,7 +516,7 @@ impl<'a> TimelineEventHandler<'a> {
                 Some(event_item.with_kind(remote_event_item.with_reactions(reactions)))
             });
 
-            if !self.result.items_updated > 0 {
+            if self.result.items_updated == 0 {
                 if let Some(reactions) = self.pending_reactions.get_mut(&rel.event_id) {
                     if !reactions.remove(&redacts) {
                         error!(

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

@@ -386,6 +386,20 @@ impl From<RoomEncryptedEventContent> for EncryptedMessage {
 /// Value: The group of reactions.
 pub type BundledReactions = IndexMap<String, ReactionGroup>;
 
+pub trait BundledReactionsExt {
+    fn by_key(&self, key: &str) -> Option<&ReactionGroup>;
+}
+
+impl BundledReactionsExt for BundledReactions {
+    /// Get a reaction group by it's key
+    fn by_key(&self, key: &str) -> Option<&ReactionGroup> {
+        self.iter().find_map(|(k, v)| match k == key {
+            true => Some(v),
+            false => None,
+        })
+    }
+}
+
 // The long type after a long visibility specified trips up rustfmt currently.
 // This works around. Report: https://github.com/rust-lang/rustfmt/issues/5703
 type ReactionGroupInner = IndexMap<(Option<OwnedTransactionId>, Option<OwnedEventId>), OwnedUserId>;
@@ -402,6 +416,27 @@ impl ReactionGroup {
     pub fn senders(&self) -> impl Iterator<Item = &UserId> {
         self.values().map(AsRef::as_ref)
     }
+
+    /// All reactions within this reaction group that were sent by the given
+    /// user Note that it is possible for a user to have sent multiple
+    /// reactions with the same key
+    pub fn by_sender(
+        &self,
+        user_id: &UserId,
+    ) -> impl Iterator<Item = (Option<&OwnedTransactionId>, Option<&OwnedEventId>)> {
+        let user_id = user_id.to_owned();
+        self.as_refs().filter_map(move |(k, v)| match v == &user_id {
+            true => Some(k),
+            false => None,
+        })
+    }
+
+    pub fn as_refs(
+        &self,
+    ) -> impl Iterator<Item = ((Option<&OwnedTransactionId>, Option<&OwnedEventId>), &OwnedUserId)>
+    {
+        self.iter().map(|(k, v)| ((k.0.as_ref(), k.1.as_ref()), v))
+    }
 }
 
 impl Deref for ReactionGroup {

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

@@ -29,9 +29,9 @@ mod local;
 mod remote;
 
 pub use self::content::{
-    AnyOtherFullStateEventContent, BundledReactions, EncryptedMessage, InReplyToDetails,
-    MemberProfileChange, MembershipChange, Message, OtherState, ReactionGroup, RepliedToEvent,
-    RoomMembershipChange, Sticker, TimelineItemContent,
+    AnyOtherFullStateEventContent, BundledReactions, BundledReactionsExt, EncryptedMessage,
+    InReplyToDetails, MemberProfileChange, MembershipChange, Message, OtherState, ReactionGroup,
+    RepliedToEvent, RoomMembershipChange, Sticker, TimelineItemContent,
 };
 pub(super) use self::{
     local::LocalEventTimelineItem,

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

@@ -39,6 +39,7 @@ use ruma::{
         fully_read::FullyReadEvent,
         receipt::{Receipt, ReceiptThread, ReceiptType},
         relation::Annotation,
+        room::redaction::RoomRedactionEventContent,
         AnyMessageLikeEventContent, AnyRoomAccountDataEvent, AnySyncEphemeralRoomEvent,
     },
     push::Action,
@@ -58,6 +59,7 @@ use super::{
         update_read_marker, Flow, HandleEventResult, TimelineEventHandler, TimelineEventKind,
         TimelineEventMetadata, TimelineItemPosition,
     },
+    reactions::ReactionToggleResult,
     rfind_event_by_id, rfind_event_item,
     traits::RoomDataProvider,
     EventSendState, EventTimelineItem, InReplyToDetails, Message, Profile, RelativePosition,
@@ -266,6 +268,37 @@ impl<P: RoomDataProvider> TimelineInner<P> {
             .handle_event(kind);
     }
 
+    /// Handle the local redaction of an event.
+    #[instrument(skip_all)]
+    pub(super) async fn handle_local_redaction_event(
+        &self,
+        txn_id: OwnedTransactionId,
+        redacts: OwnedEventId,
+        content: RoomRedactionEventContent,
+    ) {
+        // TODO: Refactor duplication with `handle_local_event`.
+        let sender = self.room_data_provider.own_user_id().to_owned();
+        let sender_profile = self.room_data_provider.profile(&sender).await;
+        let event_meta = TimelineEventMetadata {
+            sender,
+            sender_profile,
+            timestamp: MilliSecondsSinceUnixEpoch::now(),
+            is_own_event: true,
+            // FIXME: Should we supply something here for encrypted rooms?
+            encryption_info: None,
+            read_receipts: Default::default(),
+            // An event sent by ourself is never matched against push rules.
+            is_highlighted: false,
+        };
+
+        let flow = Flow::Local { txn_id };
+        let kind = TimelineEventKind::Redaction { redacts, content };
+
+        let mut state = self.state.lock().await;
+        TimelineEventHandler::new(event_meta, flow, &mut state, self.track_read_receipts)
+            .handle_event(kind);
+    }
+
     /// Update the send state of a local event represented by a transaction ID.
     ///
     /// If no local event is found, a warning is raised.
@@ -337,6 +370,89 @@ impl<P: RoomDataProvider> TimelineInner<P> {
         state.items.set(idx, Arc::new(new_item));
     }
 
+    /// Update the send state of a local reaction represented by a transaction
+    /// ID.
+    ///
+    /// If no local reaction is found, a warning is raised.
+    pub(super) async fn update_reaction_send_state(
+        &self,
+        annotation: &Annotation,
+        result: &ReactionToggleResult,
+    ) {
+        let mut state = self.state.lock().await;
+        let (remote_echo_to_add, local_echo_to_remove) = match result {
+            ReactionToggleResult::AddSuccess { event_id, txn_id } => (Some(event_id), Some(txn_id)),
+            ReactionToggleResult::AddFailure { txn_id } => (None, Some(txn_id)),
+            ReactionToggleResult::RedactSuccess => return, // Nothing to do
+            ReactionToggleResult::RedactFailure { event_id } => (Some(event_id), None),
+        };
+
+        // TODO: Also handle pending reactions?
+        let related = rfind_event_item(&state.items, |it| {
+            it.event_id().is_some_and(|it| it == annotation.event_id)
+        });
+
+        let Some((idx, related)) = related else {
+            // Event isn't found at all.
+            warn!("Timeline item not found, can't update reaction ID");
+            return;
+        };
+        let Some(remote_related) = related.as_remote() else {
+            error!("inconsistent state: reaction received on a non-remote event item");
+            return;
+        };
+
+        let new_reactions = {
+            let mut reactions = remote_related.reactions.clone();
+            let reaction_group = reactions.entry(annotation.key.clone()).or_default();
+
+            // Remove the local echo from the related event.
+            if let Some(txn_id) = local_echo_to_remove {
+                if reaction_group.0.remove(&(Some(txn_id.to_owned()), None)).is_none() {
+                    warn!(
+                        "Tried to remove reaction by transaction ID, but didn't \
+                             find matching reaction in the related event's reactions"
+                    );
+                }
+            }
+            // Add the remote echo to the related event
+            if let Some(event_id) = remote_echo_to_add {
+                let own_user_id = self.room_data_provider.own_user_id().to_owned();
+                reaction_group.0.insert((None, Some(event_id.to_owned())), own_user_id);
+            };
+            if reaction_group.0.is_empty() {
+                reactions.remove(&annotation.key);
+            }
+
+            reactions
+        };
+        let new_related = related.with_kind(remote_related.with_reactions(new_reactions));
+
+        // Update the reactions stored in the timeline state
+        {
+            // Remove the local echo from reaction_map
+            // (should the local echo already be up-to-date after event handling?)
+            if let Some(txn_id) = local_echo_to_remove {
+                if state.reaction_map.remove(&(Some(txn_id.to_owned()), None)).is_none() {
+                    warn!(
+                        "Tried to remove reaction by transaction ID, but didn't \
+                             find matching reaction in the reaction map"
+                    );
+                }
+            }
+            // Add the remote echo to the reaction_map
+            if let Some(event_id) = remote_echo_to_add {
+                let own_user_id = self.room_data_provider.own_user_id().to_owned();
+                state
+                    .reaction_map
+                    .insert((None, Some(event_id.to_owned())), (own_user_id, annotation.clone()));
+            };
+        }
+
+        // Update the related item
+        state.items.set(idx, Arc::new(TimelineItem::Event(new_related)));
+    }
+
     pub(super) async fn prepare_retry(
         &self,
         txn_id: &TransactionId,