fix(ui): Decrypt TimelineEventKind::UnableToDecrypt coming from the event cache

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

@@ -393,6 +393,10 @@ async fn room_event_cache_updates_task(
                         },
                     )
                     .await;
+
+                if matches!(origin, EventsOrigin::Cache) {
+                    timeline_controller.retry_event_decryption(None).await;
+                }
             }
 
             RoomEventCacheUpdate::AddEphemeralEvents { events } => {
@@ -448,8 +452,6 @@ where
     pin_mut!(stream);
 
     while let Some(update) = stream.next().await {
-        let room = timeline_controller.room();
-
         match update {
             Ok(info) => {
                 let mut session_ids = BTreeSet::new();
@@ -458,10 +460,10 @@ where
                     session_ids.extend(set);
                 }
 
-                timeline_controller.retry_event_decryption(room, Some(session_ids)).await;
+                timeline_controller.retry_event_decryption(Some(session_ids)).await;
             }
             // We lagged, so retry every event.
-            Err(_) => timeline_controller.retry_event_decryption(room, None).await,
+            Err(_) => timeline_controller.retry_event_decryption(None).await,
         }
     }
 }
@@ -484,8 +486,7 @@ where
             // 2. It will fail to decrypt the event, but try to download the room key to decrypt it
             //    if the `BackupDownloadStrategy` has been set to `AfterDecryptionFailure`.
             Ok(BackupState::Enabled) | Err(_) => {
-                let room = timeline_controller.room();
-                timeline_controller.retry_event_decryption(room, None).await;
+                timeline_controller.retry_event_decryption(None).await;
             }
             // The other states aren't interesting since they are either still enabling
             // the backup or have the backup in the disabled state.
@@ -535,7 +536,6 @@ async fn room_key_received_task<S>(
             }
         };
 
-        let room = timeline_controller.room();
-        timeline_controller.retry_event_decryption(room, session_ids).await;
+        timeline_controller.retry_event_decryption(session_ids).await;
     }
 }

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

@@ -1475,13 +1475,9 @@ impl TimelineController {
         state.items.all_remote_events().last().map(|event_meta| &event_meta.event_id).cloned()
     }
 
-    #[instrument(skip(self, room), fields(room_id = ?room.room_id()))]
-    pub(super) async fn retry_event_decryption(
-        &self,
-        room: &Room,
-        session_ids: Option<BTreeSet<String>>,
-    ) {
-        self.retry_event_decryption_inner(room.to_owned(), session_ids).await
+    #[instrument(skip(self), fields(room_id = ?self.room().room_id()))]
+    pub(super) async fn retry_event_decryption(&self, session_ids: Option<BTreeSet<String>>) {
+        self.retry_event_decryption_inner(self.room().to_owned(), session_ids).await
     }
 }
 

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

@@ -230,16 +230,13 @@ impl Timeline {
         session_ids: impl IntoIterator<Item = S>,
     ) {
         self.controller
-            .retry_event_decryption(
-                self.room(),
-                Some(session_ids.into_iter().map(Into::into).collect()),
-            )
+            .retry_event_decryption(Some(session_ids.into_iter().map(Into::into).collect()))
             .await;
     }
 
     #[tracing::instrument(skip(self))]
     async fn retry_decryption_for_all_events(&self) {
-        self.controller.retry_event_decryption(self.room(), None).await;
+        self.controller.retry_event_decryption(None).await;
     }
 
     /// Get the current timeline item for the given event ID, if any.

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

@@ -14,24 +14,24 @@
 
 use std::iter;
 
-use matrix_sdk::{event_handler::EventHandler, Client};
+use matrix_sdk::event_handler::EventHandler;
 use ruma::{
     events::{forwarded_room_key::ToDeviceForwardedRoomKeyEvent, room_key::ToDeviceRoomKeyEvent},
     OwnedRoomId,
 };
-use tracing::{debug_span, error, trace, Instrument};
+use tracing::{debug_span, trace, Instrument};
 
 use super::controller::TimelineController;
 
 pub(super) fn handle_room_key_event(
     timeline: TimelineController,
     room_id: OwnedRoomId,
-) -> impl EventHandler<ToDeviceRoomKeyEvent, (Client,)> {
-    move |event: ToDeviceRoomKeyEvent, client: Client| {
+) -> impl EventHandler<ToDeviceRoomKeyEvent, ()> {
+    move |event: ToDeviceRoomKeyEvent| {
         async move {
             let event_room_id = event.content.room_id;
             let session_id = event.content.session_id;
-            retry_decryption(client, timeline, room_id, event_room_id, session_id).await;
+            retry_decryption(timeline, room_id, event_room_id, session_id).await;
         }
         .instrument(debug_span!("handle_room_key_event"))
     }
@@ -40,19 +40,18 @@ pub(super) fn handle_room_key_event(
 pub(super) fn handle_forwarded_room_key_event(
     timeline: TimelineController,
     room_id: OwnedRoomId,
-) -> impl EventHandler<ToDeviceForwardedRoomKeyEvent, (Client,)> {
-    move |event: ToDeviceForwardedRoomKeyEvent, client: Client| {
+) -> impl EventHandler<ToDeviceForwardedRoomKeyEvent, ()> {
+    move |event: ToDeviceForwardedRoomKeyEvent| {
         async move {
             let event_room_id = event.content.room_id;
             let session_id = event.content.session_id;
-            retry_decryption(client, timeline, room_id, event_room_id, session_id).await;
+            retry_decryption(timeline, room_id, event_room_id, session_id).await;
         }
         .instrument(debug_span!("handle_forwarded_room_key_event"))
     }
 }
 
 async fn retry_decryption(
-    client: Client,
     timeline: TimelineController,
     room_id: OwnedRoomId,
     event_room_id: OwnedRoomId,
@@ -66,10 +65,5 @@ async fn retry_decryption(
         return;
     }
 
-    let Some(room) = client.get_room(&room_id) else {
-        error!("Failed to fetch room object");
-        return;
-    };
-
-    timeline.retry_event_decryption(&room, Some(iter::once(session_id).collect())).await;
+    timeline.retry_event_decryption(Some(iter::once(session_id).collect())).await;
 }