refactor(ffi): simplify FFI layer and use only EmbeddedEventDetails there for both thread latest event + replied-to event item

Author: bnjbvr

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

@@ -36,7 +36,7 @@ use matrix_sdk_ui::timeline::{
     TimelineUniqueId as SdkTimelineUniqueId,
 };
 use mime::Mime;
-use reply::{InReplyToDetails, RepliedToEventDetails};
+use reply::{EmbeddedEventDetails, InReplyToDetails};
 use ruma::{
     events::{
         location::{AssetType as RumaAssetType, LocationContent, ZoomLevel},
@@ -689,7 +689,7 @@ impl Timeline {
         match replied_to {
             Ok(Some(replied_to)) => Ok(Arc::new(InReplyToDetails::new(
                 event_id_str,
-                RepliedToEventDetails::Ready {
+                EmbeddedEventDetails::Ready {
                     content: replied_to.content().clone().into(),
                     sender: replied_to.sender().to_string(),
                     sender_profile: replied_to.sender_profile().into(),
@@ -698,12 +698,12 @@ impl Timeline {
 
             Ok(None) => Ok(Arc::new(InReplyToDetails::new(
                 event_id_str,
-                RepliedToEventDetails::Error { message: "unsupported event".to_owned() },
+                EmbeddedEventDetails::Error { message: "unsupported event".to_owned() },
             ))),
 
             Err(e) => Ok(Arc::new(InReplyToDetails::new(
                 event_id_str,
-                RepliedToEventDetails::Error { message: e.to_string() },
+                EmbeddedEventDetails::Error { message: e.to_string() },
             ))),
         }
     }

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

@@ -15,17 +15,16 @@
 use std::{collections::HashMap, sync::Arc};
 
 use matrix_sdk::crypto::types::events::UtdCause;
-use matrix_sdk_ui::timeline::TimelineDetails;
 use ruma::events::{room::MediaSource as RumaMediaSource, EventContent};
 
 use super::{
-    content::{Reaction, TimelineItemContent},
-    reply::InReplyToDetails,
+    content::Reaction,
+    reply::{EmbeddedEventDetails, InReplyToDetails},
 };
 use crate::{
     error::ClientError,
     ruma::{ImageInfo, MediaSource, MediaSourceExt, Mentions, MessageType, PollKind},
-    timeline::{content::ReactionSenderData, ProfileDetails},
+    timeline::content::ReactionSenderData,
     utils::Timestamp,
 };
 
@@ -241,42 +240,22 @@ pub struct PollAnswer {
 
 #[derive(Clone, uniffi::Object)]
 pub struct ThreadSummary {
-    pub latest_event: ThreadSummaryLatestEventDetails,
+    pub latest_event: EmbeddedEventDetails,
     pub num_replies: usize,
 }
 
 #[matrix_sdk_ffi_macros::export]
 impl ThreadSummary {
-    pub fn latest_event(&self) -> ThreadSummaryLatestEventDetails {
+    pub fn latest_event(&self) -> EmbeddedEventDetails {
         self.latest_event.clone()
     }
 }
 
-#[derive(Clone, uniffi::Enum)]
-#[allow(clippy::large_enum_variant)]
-// TODO: unify with the FFI replied-to-event-details
-pub enum ThreadSummaryLatestEventDetails {
-    Unavailable,
-    Pending,
-    Ready { sender: String, sender_profile: ProfileDetails, content: TimelineItemContent },
-    Error { message: String },
-}
-
 impl From<matrix_sdk_ui::timeline::ThreadSummary> for ThreadSummary {
     fn from(value: matrix_sdk_ui::timeline::ThreadSummary) -> Self {
-        let latest_event = match value.latest_event {
-            TimelineDetails::Unavailable => ThreadSummaryLatestEventDetails::Unavailable,
-            TimelineDetails::Pending => ThreadSummaryLatestEventDetails::Pending,
-            TimelineDetails::Ready(event) => ThreadSummaryLatestEventDetails::Ready {
-                content: event.content.into(),
-                sender: event.sender.to_string(),
-                sender_profile: (&event.sender_profile).into(),
-            },
-            TimelineDetails::Error(message) => {
-                ThreadSummaryLatestEventDetails::Error { message: message.to_string() }
-            }
-        };
-
-        Self { latest_event, num_replies: value.num_replies }
+        Self {
+            latest_event: EmbeddedEventDetails::from(value.latest_event),
+            num_replies: value.num_replies,
+        }
     }
 }

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

@@ -12,18 +12,18 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use matrix_sdk_ui::timeline::TimelineDetails;
+use matrix_sdk_ui::timeline::{EmbeddedEvent, TimelineDetails};
 
 use super::{content::TimelineItemContent, ProfileDetails};
 
 #[derive(Clone, uniffi::Object)]
 pub struct InReplyToDetails {
     event_id: String,
-    event: RepliedToEventDetails,
+    event: EmbeddedEventDetails,
 }
 
 impl InReplyToDetails {
-    pub(crate) fn new(event_id: String, event: RepliedToEventDetails) -> Self {
+    pub(crate) fn new(event_id: String, event: EmbeddedEventDetails) -> Self {
         Self { event_id, event }
     }
 }
@@ -34,36 +34,40 @@ impl InReplyToDetails {
         self.event_id.clone()
     }
 
-    pub fn event(&self) -> RepliedToEventDetails {
+    pub fn event(&self) -> EmbeddedEventDetails {
         self.event.clone()
     }
 }
 
 impl From<matrix_sdk_ui::timeline::InReplyToDetails> for InReplyToDetails {
     fn from(inner: matrix_sdk_ui::timeline::InReplyToDetails) -> Self {
-        let event_id = inner.event_id.to_string();
-        let event = match &inner.event {
-            TimelineDetails::Unavailable => RepliedToEventDetails::Unavailable,
-            TimelineDetails::Pending => RepliedToEventDetails::Pending,
-            TimelineDetails::Ready(event) => RepliedToEventDetails::Ready {
-                content: event.content().clone().into(),
-                sender: event.sender().to_string(),
-                sender_profile: event.sender_profile().into(),
-            },
-            TimelineDetails::Error(err) => {
-                RepliedToEventDetails::Error { message: err.to_string() }
-            }
-        };
-
-        Self { event_id, event }
+        Self { event_id: inner.event_id.to_string(), event: inner.event.into() }
     }
 }
 
 #[derive(Clone, uniffi::Enum)]
 #[allow(clippy::large_enum_variant)]
-pub enum RepliedToEventDetails {
+pub enum EmbeddedEventDetails {
     Unavailable,
     Pending,
     Ready { content: TimelineItemContent, sender: String, sender_profile: ProfileDetails },
     Error { message: String },
 }
+
+impl From<TimelineDetails<Box<EmbeddedEvent>>> for EmbeddedEventDetails {
+    fn from(event: TimelineDetails<Box<EmbeddedEvent>>) -> Self {
+        match event {
+            TimelineDetails::Unavailable => EmbeddedEventDetails::Unavailable,
+            TimelineDetails::Pending => EmbeddedEventDetails::Pending,
+            TimelineDetails::Ready(event) => {
+                let sender_profile = event.sender_profile().into();
+                EmbeddedEventDetails::Ready {
+                    content: event.content.into(),
+                    sender: event.sender.to_string(),
+                    sender_profile,
+                }
+            }
+            TimelineDetails::Error(err) => EmbeddedEventDetails::Error { message: err.to_string() },
+        }
+    }
+}