ffi: create EventShieldsProvider to load shields on demand in the clients

Author: jmartinesp

bindings/matrix-sdk-ffi/src/timeline/mod.rs

@@ -1047,7 +1047,7 @@ pub struct EventTimelineItem {
     read_receipts: HashMap<String, Receipt>,
     origin: Option<EventItemOrigin>,
     can_be_replied_to: bool,
-    message_shield: Option<ShieldState>,
+    shields_provider: Arc<EventShieldsProvider>,
 }
 
 impl From<matrix_sdk_ui::timeline::EventTimelineItem> for EventTimelineItem {
@@ -1066,7 +1066,9 @@ impl From<matrix_sdk_ui::timeline::EventTimelineItem> for EventTimelineItem {
                     .collect(),
             })
             .collect();
+        let value = Arc::new(value);
         let debug_info_provider = Arc::new(EventTimelineItemDebugInfoProvider(value.clone()));
+        let shields_provider = Arc::new(EventShieldsProvider(value.clone()));
         let read_receipts =
             value.read_receipts().iter().map(|(k, v)| (k.to_string(), v.clone().into())).collect();
         Self {
@@ -1085,7 +1087,7 @@ impl From<matrix_sdk_ui::timeline::EventTimelineItem> for EventTimelineItem {
             read_receipts,
             origin: value.origin(),
             can_be_replied_to: value.can_be_replied_to(),
-            message_shield: value.get_shield(false).map(Into::into),
+            shields_provider,
         }
     }
 }
@@ -1104,7 +1106,7 @@ impl From<ruma::events::receipt::Receipt> for Receipt {
 /// Wrapper to retrieve the debug info lazily instead of immediately
 /// transforming it for each timeline event.
 #[derive(uniffi::Object)]
-pub struct EventTimelineItemDebugInfoProvider(matrix_sdk_ui::timeline::EventTimelineItem);
+pub struct EventTimelineItemDebugInfoProvider(Arc<matrix_sdk_ui::timeline::EventTimelineItem>);
 
 #[uniffi::export]
 impl EventTimelineItemDebugInfoProvider {
@@ -1267,3 +1269,14 @@ impl TryFrom<EditedContent> for SdkEditedContent {
         }
     }
 }
+
+/// Wrapper to retrieve the shields info lazily.
+#[derive(Clone, uniffi::Object)]
+pub struct EventShieldsProvider(Arc<matrix_sdk_ui::timeline::EventTimelineItem>);
+
+#[uniffi::export]
+impl EventShieldsProvider {
+    fn get_shields(&self, strict: bool) -> Option<ShieldState> {
+        self.0.get_shield(strict).map(Into::into)
+    }
+}

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

@@ -86,6 +86,9 @@ pub enum RedactError {
     #[error("Local event to redact wasn't found for transaction {0}")]
     LocalEventNotFound(OwnedTransactionId),
 
+    #[error("Local event with transaction id {0} had a remote `TimelineItemHandle`. This should never happen.")]
+    InvalidTimelineItemHandle(OwnedTransactionId),
+
     /// An error happened while attempting to redact an event.
     #[error(transparent)]
     HttpError(#[from] HttpError),

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

@@ -605,25 +605,30 @@ impl Timeline {
     ) -> Result<(), Error> {
         match id {
             TimelineEventItemId::TransactionId(transaction_id) => {
-                let Some(event) = self.item_by_transaction_id(transaction_id).await else {
-                    return Err(Error::RedactError(RedactError::LocalEventNotFound(
+                let item = self.item_by_transaction_id(transaction_id).await;
+
+                match item.as_ref().map(|i| i.handle()) {
+                    Some(TimelineItemHandle::Local(handle)) => {
+                        handle.abort().await.map_err(RoomSendQueueError::StorageError)?;
+                        Ok(())
+                    }
+                    Some(TimelineItemHandle::Remote(_)) => Err(Error::RedactError(
+                        RedactError::InvalidTimelineItemHandle(transaction_id.to_owned()),
+                    )),
+                    None => Err(Error::RedactError(RedactError::LocalEventNotFound(
                         transaction_id.to_owned(),
-                    )));
-                };
-                let TimelineItemHandle::Local(handle) = event.handle() else {
-                    panic!("If the item is local, this should never happen");
-                };
-                handle.abort().await.map_err(RoomSendQueueError::StorageError)?;
+                    ))),
+                }
             }
             TimelineEventItemId::EventId(event_id) => {
                 self.room()
                     .redact(event_id, reason, None)
                     .await
-                    .map_err(RedactError::HttpError)
-                    .map_err(Error::RedactError)?;
+                    .map_err(|e| Error::RedactError(RedactError::HttpError(e)))?;
+
+                Ok(())
             }
         }
-        Ok(())
     }
 
     /// Redact an event.

crates/matrix-sdk-ui/tests/integration/timeline/mod.rs

@@ -30,19 +30,23 @@ use matrix_sdk_test::{
 };
 use matrix_sdk_ui::{
     timeline::{
-        AnyOtherFullStateEventContent, EventSendState, RoomExt, TimelineItemContent,
-        VirtualTimelineItem,
+        AnyOtherFullStateEventContent, Error, EventSendState, RedactError, RoomExt,
+        TimelineEventItemId, TimelineItemContent, VirtualTimelineItem,
     },
     RoomListService, Timeline,
 };
-use ruma::{event_id, events::room::{encryption::RoomEncryptionEventContent, message::RoomMessageEventContent}, owned_event_id, room_id, user_id, MilliSecondsSinceUnixEpoch};
+use ruma::{
+    event_id,
+    events::room::{encryption::RoomEncryptionEventContent, message::RoomMessageEventContent},
+    owned_event_id, room_id, user_id, MilliSecondsSinceUnixEpoch,
+};
 use serde_json::json;
 use stream_assert::{assert_next_matches, assert_pending};
 use wiremock::{
     matchers::{header, method, path_regex},
     Mock, ResponseTemplate,
 };
-use matrix_sdk_ui::timeline::{Error, RedactError, TimelineEventItemId};
+
 use crate::mock_sync;
 
 mod echo;