feat(ffi): expose media upload progress through EventSendState::NotSentYet

Signed-off-by: Johannes Marbach <n0-0ne+github@mailbox.org>

Author: Johennes

bindings/matrix-sdk-ffi/src/client.rs

@@ -224,6 +224,30 @@ impl From<matrix_sdk::TransmissionProgress> for TransmissionProgress {
     }
 }
 
+/// Progress of an operation in abstract units.
+///
+/// Contrary to [`TransmissionProgress`], this allows tracking the progress
+/// of sending or receiving a payload in estimated pseudo units representing a
+/// percentage. This is helpful in cases where the exact progress in bytes isn't
+/// known, for instance, because encryption (which changes the size) happens on
+/// the fly.
+#[derive(Clone, Copy, uniffi::Record)]
+pub struct AbstractProgress {
+    /// How many units were already transferred.
+    pub current: u64,
+    /// How many units there are in total.
+    pub total: u64,
+}
+
+impl From<matrix_sdk::AbstractProgress> for AbstractProgress {
+    fn from(value: matrix_sdk::AbstractProgress) -> Self {
+        Self {
+            current: value.current.try_into().unwrap_or(u64::MAX),
+            total: value.total.try_into().unwrap_or(u64::MAX),
+        }
+    }
+}
+
 #[derive(uniffi::Object)]
 pub struct Client {
     pub(crate) inner: AsyncRuntimeDropped<MatrixClient>,

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

@@ -35,8 +35,8 @@ use matrix_sdk_common::{
     stream::StreamExt,
 };
 use matrix_sdk_ui::timeline::{
-    self, AttachmentSource, EventItemOrigin, Profile, TimelineDetails,
-    TimelineUniqueId as SdkTimelineUniqueId,
+    self, AttachmentSource, EventItemOrigin, EventSendProgress as SdkEventSendProgress, Profile,
+    TimelineDetails, TimelineUniqueId as SdkTimelineUniqueId,
 };
 use mime::Mime;
 use reply::{EmbeddedEventDetails, InReplyToDetails};
@@ -66,7 +66,7 @@ use uuid::Uuid;
 use self::content::TimelineItemContent;
 pub use self::msg_like::MessageContent;
 use crate::{
-    client::ProgressWatcher,
+    client::{AbstractProgress, ProgressWatcher},
     error::{ClientError, RoomError},
     event::EventOrTransactionId,
     helpers::unwrap_or_clone_arc,
@@ -270,6 +270,31 @@ impl TryInto<Reply> for ReplyParameters {
     }
 }
 
+/// This type represents the "send progress" of a local event timeline item.
+#[derive(Clone, Copy, uniffi::Enum)]
+pub enum EventSendProgress {
+    /// A media is being uploaded.
+    MediaUpload {
+        /// The index of the media within the transaction. A file and its
+        /// thumbnail share the same index.
+        index: u64,
+
+        /// The current combined upload progress for both the file and,
+        /// if it exists, its thumbnail.
+        progress: AbstractProgress,
+    },
+}
+
+impl From<SdkEventSendProgress> for EventSendProgress {
+    fn from(value: SdkEventSendProgress) -> Self {
+        match value {
+            SdkEventSendProgress::MediaUpload { index, progress } => {
+                Self::MediaUpload { index, progress: progress.into() }
+            }
+        }
+    }
+}
+
 #[matrix_sdk_ffi_macros::export]
 impl Timeline {
     pub async fn add_listener(&self, listener: Box<dyn TimelineListener>) -> Arc<TaskHandle> {
@@ -1018,7 +1043,10 @@ impl TimelineItem {
 #[derive(Clone, uniffi::Enum)]
 pub enum EventSendState {
     /// The local event has not been sent yet.
-    NotSentYet,
+    NotSentYet {
+        /// The progress of the sending operation, if any is available.
+        progress: Option<EventSendProgress>,
+    },
 
     /// The local event has been sent to the server, but unsuccessfully: The
     /// sending has failed.
@@ -1043,7 +1071,9 @@ impl From<&matrix_sdk_ui::timeline::EventSendState> for EventSendState {
         use matrix_sdk_ui::timeline::EventSendState::*;
 
         match value {
-            NotSentYet => Self::NotSentYet,
+            NotSentYet { progress } => {
+                Self::NotSentYet { progress: progress.clone().map(|p| p.into()) }
+            }
             SendingFailed { error, is_recoverable } => {
                 let as_queue_wedge_error: matrix_sdk::QueueWedgeError = (&**error).into();
                 Self::SendingFailed {