feat(sdk): LatestEventValue represents all kind of suitable latest events.

This patch adds new variants to `LatestEventValue` that represent
all the possible suitable latest events. It's heavily inspired by
`matrix_sdk_base::latest_event::PossibleLatestEvent`. It uses the
new `find_and_map` method to find a suitable `TimelineEvent` and to
map it into a `LatestEventValue`. This method is heavily inspired by
`matrix_sdk_base::latest_value::is_suitable_for_latest_event`.

To be able to provide the `power_levels` to `find_and_map`, a
`WeakClient` is required by `LatestEvents::new`. It flows up to a
`WeakRoom` in `RoomLatestEvents`, used to create or to update the
`LatestEventValue`.

A particular care is applied to re-compute the `power_levels` only when
necessary and once **per room** (and not per latest event value).
Fetching the `power_levels` requires an access to the storage, it's
not anodyne.

Author: Hywan

crates/matrix-sdk/src/client/mod.rs

@@ -2705,7 +2705,11 @@ impl Client {
         self.inner
             .latest_events
             .get_or_init(|| async {
-                LatestEvents::new(self.event_cache().clone(), SendQueue::new(self.clone()))
+                LatestEvents::new(
+                    WeakClient::from_client(self),
+                    self.event_cache().clone(),
+                    SendQueue::new(self.clone()),
+                )
             })
             .await
     }
@@ -2797,7 +2801,7 @@ impl Client {
 
 /// A weak reference to the inner client, useful when trying to get a handle
 /// on the owning client.
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub(crate) struct WeakClient {
     client: Weak<ClientInner>,
 }

crates/matrix-sdk/src/latest_events/latest_event.rs

@@ -13,9 +13,25 @@
 // limitations under the License.
 
 use eyeball::{AsyncLock, SharedObservable, Subscriber};
-use ruma::{EventId, OwnedEventId, OwnedRoomId, RoomId};
+use matrix_sdk_base::event_cache::Event;
+use ruma::{
+    events::{
+        call::{invite::SyncCallInviteEvent, notify::SyncCallNotifyEvent},
+        poll::unstable_start::SyncUnstablePollStartEvent,
+        relation::RelationType,
+        room::{
+            member::{MembershipState, SyncRoomMemberEvent},
+            message::{MessageType, SyncRoomMessageEvent},
+            power_levels::RoomPowerLevels,
+        },
+        sticker::SyncStickerEvent,
+        AnySyncMessageLikeEvent, AnySyncStateEvent, AnySyncTimelineEvent,
+    },
+    EventId, OwnedEventId, OwnedRoomId, RoomId, UserId,
+};
+use tracing::warn;
 
-use crate::event_cache::RoomEventCache;
+use crate::{event_cache::RoomEventCache, room::WeakRoom};
 
 /// The latest event of a room or a thread.
 ///
@@ -35,12 +51,13 @@ impl LatestEvent {
         room_id: &RoomId,
         thread_id: Option<&EventId>,
         room_event_cache: &RoomEventCache,
+        weak_room: &WeakRoom,
     ) -> Self {
         Self {
             room_id: room_id.to_owned(),
             thread_id: thread_id.map(ToOwned::to_owned),
             value: SharedObservable::new_async(
-                LatestEventValue::new(room_id, thread_id, room_event_cache).await,
+                LatestEventValue::new(room_id, thread_id, room_event_cache, weak_room).await,
             ),
         }
     }
@@ -51,15 +68,24 @@ impl LatestEvent {
     }
 
     /// Update the inner latest event value.
-    pub async fn update(&mut self, room_event_cache: &RoomEventCache) {
-        let new_value =
-            LatestEventValue::new(&self.room_id, self.thread_id.as_deref(), room_event_cache).await;
-
-        match new_value {
-            LatestEventValue::None => {
-                // The new value is `None`. It means no new value has been
-                // computed. Let's keep the old value.
-            }
+    pub async fn update(
+        &mut self,
+        room_event_cache: &RoomEventCache,
+        power_levels: &Option<(&UserId, RoomPowerLevels)>,
+    ) {
+        let new_value = LatestEventValue::new_with_power_levels(
+            &self.room_id,
+            self.thread_id.as_deref(),
+            room_event_cache,
+            power_levels,
+        )
+        .await;
+
+        if let LatestEventValue::None = new_value {
+            // The new value is `None`. It means no new value has been
+            // computed. Let's keep the old value.
+        } else {
+            self.value.set(new_value).await;
         }
     }
 }
@@ -69,14 +95,146 @@ impl LatestEvent {
 pub enum LatestEventValue {
     /// No value has been computed yet, or no candidate value was found.
     None,
+
+    /// A `m.room.message` event.
+    RoomMessage(SyncRoomMessageEvent),
+
+    /// A `m.sticker` event.
+    Sticker(SyncStickerEvent),
+
+    /// An `org.matrix.msc3381.poll.start` event.
+    Poll(SyncUnstablePollStartEvent),
+
+    /// A `m.call.invite` event.
+    CallInvite(SyncCallInviteEvent),
+
+    /// A `m.call.notify` event.
+    CallNotify(SyncCallNotifyEvent),
+
+    /// A `m.room.member` event, more precisely a knock membership change that
+    /// can be handled by the current user.
+    KnockedStateEvent(SyncRoomMemberEvent),
 }
 
 impl LatestEventValue {
     async fn new(
+        room_id: &RoomId,
+        thread_id: Option<&EventId>,
+        room_event_cache: &RoomEventCache,
+        weak_room: &WeakRoom,
+    ) -> Self {
+        // Get the power levels of the user for the current room if the `WeakRoom` is
+        // still valid.
+        let room = weak_room.get();
+        let power_levels = match &room {
+            Some(room) => {
+                let power_levels = room.power_levels().await.ok();
+
+                Some(room.own_user_id()).zip(power_levels)
+            }
+
+            None => None,
+        };
+
+        Self::new_with_power_levels(room_id, thread_id, room_event_cache, &power_levels).await
+    }
+
+    async fn new_with_power_levels(
         _room_id: &RoomId,
         _thread_id: Option<&EventId>,
-        _room_event_cache: &RoomEventCache,
+        room_event_cache: &RoomEventCache,
+        power_levels: &Option<(&UserId, RoomPowerLevels)>,
     ) -> Self {
-        LatestEventValue::None
+        room_event_cache
+            .rfind_map_event_in_memory_by(|event| find_and_map(event, power_levels))
+            .await
+            .unwrap_or(LatestEventValue::None)
+    }
+}
+
+pub fn find_and_map(
+    event: &Event,
+    power_levels: &Option<(&UserId, RoomPowerLevels)>,
+) -> Option<LatestEventValue> {
+    // Cast the event into an `AnySyncTimelineEvent`. If deserializing fails, we
+    // ignore the event.
+    let Some(event) = event.raw().deserialize().ok() else {
+        warn!(?event, "Failed to deserialize the event when looking for a suitable latest event");
+
+        return None;
+    };
+
+    match event {
+        AnySyncTimelineEvent::MessageLike(message_like_event) => match message_like_event {
+            AnySyncMessageLikeEvent::RoomMessage(message) => {
+                if let Some(original_message) = message.as_original() {
+                    // Don't show incoming verification requests.
+                    if let MessageType::VerificationRequest(_) = original_message.content.msgtype {
+                        return None;
+                    }
+
+                    // Check if this is a replacement for another message. If it is, ignore it.
+                    let is_replacement =
+                        original_message.content.relates_to.as_ref().is_some_and(|relates_to| {
+                            if let Some(relation_type) = relates_to.rel_type() {
+                                relation_type == RelationType::Replacement
+                            } else {
+                                false
+                            }
+                        });
+
+                    if is_replacement {
+                        None
+                    } else {
+                        Some(LatestEventValue::RoomMessage(message))
+                    }
+                } else {
+                    Some(LatestEventValue::RoomMessage(message))
+                }
+            }
+
+            AnySyncMessageLikeEvent::UnstablePollStart(poll) => Some(LatestEventValue::Poll(poll)),
+
+            AnySyncMessageLikeEvent::CallInvite(invite) => {
+                Some(LatestEventValue::CallInvite(invite))
+            }
+
+            AnySyncMessageLikeEvent::CallNotify(notify) => {
+                Some(LatestEventValue::CallNotify(notify))
+            }
+
+            AnySyncMessageLikeEvent::Sticker(sticker) => Some(LatestEventValue::Sticker(sticker)),
+
+            // Encrypted events are not suitable.
+            AnySyncMessageLikeEvent::RoomEncrypted(_) => None,
+
+            // Everything else is considered not suitable.
+            _ => None,
+        },
+
+        // We don't currently support most state events
+        AnySyncTimelineEvent::State(state) => {
+            // But we make an exception for knocked state events *if* the current user
+            // can either accept or decline them.
+            if let AnySyncStateEvent::RoomMember(member) = state {
+                if matches!(member.membership(), MembershipState::Knock) {
+                    let can_accept_or_decline_knocks = match power_levels {
+                        Some((own_user_id, room_power_levels)) => {
+                            room_power_levels.user_can_invite(own_user_id)
+                                || room_power_levels.user_can_kick(own_user_id)
+                        }
+                        _ => false,
+                    };
+
+                    // The current user can act on the knock changes, so they should be
+                    // displayed
+                    if can_accept_or_decline_knocks {
+                        return Some(LatestEventValue::KnockedStateEvent(member));
+                    }
+                }
+            }
+
+            None
+        }
     }
 }