feat(send_queue): add global setting for sending media progress updates

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

Author: Johennes

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

@@ -129,6 +129,7 @@ pub struct ClientBuilder {
     decryption_settings: DecryptionSettings,
     enable_share_history_on_invite: bool,
     request_config: Option<RequestConfig>,
+    enable_send_queue_media_upload_progress_reporting: bool,
 
     #[cfg(not(target_family = "wasm"))]
     user_agent: Option<String>,
@@ -180,6 +181,7 @@ impl ClientBuilder {
             enable_share_history_on_invite: false,
             request_config: Default::default(),
             threads_enabled: false,
+            enable_send_queue_media_upload_progress_reporting: false,
         })
     }
 
@@ -386,6 +388,18 @@ impl ClientBuilder {
         Arc::new(builder)
     }
 
+    /// Set whether to enable progress reporting for media uploads in the send
+    /// queue.
+    pub fn enable_send_queue_media_upload_progress_reporting(
+        self: Arc<Self>,
+        enable_send_queue_media_upload_progress_reporting: bool,
+    ) -> Arc<Self> {
+        let mut builder = unwrap_or_clone_arc(self);
+        builder.enable_send_queue_media_upload_progress_reporting =
+            enable_send_queue_media_upload_progress_reporting;
+        Arc::new(builder)
+    }
+
     /// Add a default request config to this client.
     pub fn request_config(self: Arc<Self>, config: RequestConfig) -> Arc<Self> {
         let mut builder = unwrap_or_clone_arc(self);
@@ -524,7 +538,10 @@ impl ClientBuilder {
             .with_encryption_settings(builder.encryption_settings)
             .with_room_key_recipient_strategy(builder.room_key_recipient_strategy)
             .with_decryption_settings(builder.decryption_settings)
-            .with_enable_share_history_on_invite(builder.enable_share_history_on_invite);
+            .with_enable_share_history_on_invite(builder.enable_share_history_on_invite)
+            .with_enable_send_queue_media_upload_progress_reporting(
+                builder.enable_send_queue_media_upload_progress_reporting,
+            );
 
         match builder.sliding_sync_version_builder {
             SlidingSyncVersionBuilder::None => {

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

@@ -114,6 +114,7 @@ pub struct ClientBuilder {
     enable_share_history_on_invite: bool,
     cross_process_store_locks_holder_name: String,
     threading_support: ThreadingSupport,
+    enable_send_queue_media_upload_progress_reporting: bool,
 }
 
 impl ClientBuilder {
@@ -145,6 +146,7 @@ impl ClientBuilder {
             cross_process_store_locks_holder_name:
                 Self::DEFAULT_CROSS_PROCESS_STORE_LOCKS_HOLDER_NAME.to_owned(),
             threading_support: ThreadingSupport::Disabled,
+            enable_send_queue_media_upload_progress_reporting: false,
         }
     }
 
@@ -489,6 +491,16 @@ impl ClientBuilder {
         self
     }
 
+    /// Set whether to report media upload progress via the send queue.
+    pub fn with_enable_send_queue_media_upload_progress_reporting(
+        mut self,
+        enable_send_queue_media_upload_progress_reporting: bool,
+    ) -> Self {
+        self.enable_send_queue_media_upload_progress_reporting =
+            enable_send_queue_media_upload_progress_reporting;
+        self
+    }
+
     /// Create a [`Client`] with the options set on this builder.
     ///
     /// # Errors
@@ -573,7 +585,10 @@ impl ClientBuilder {
         });
 
         // Enable the send queue by default.
-        let send_queue = Arc::new(SendQueueData::new(true));
+        let send_queue = Arc::new(SendQueueData::new(
+            true,
+            self.enable_send_queue_media_upload_progress_reporting,
+        ));
 
         let server_info = ClientServerInfo {
             server_versions: match self.server_versions {

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

@@ -246,6 +246,7 @@ impl SendQueue {
             data.is_dropping.clone(),
             &self.client,
             owned_room_id.clone(),
+            data.report_media_upload_progress.clone(),
         );
 
         map.insert(owned_room_id, room_q.clone());
@@ -330,18 +331,22 @@ pub(super) struct SendQueueData {
 
     /// Are we currently dropping the Client?
     is_dropping: Arc<AtomicBool>,
+
+    /// Will media upload progress be reported via send queue updates?
+    report_media_upload_progress: Arc<AtomicBool>,
 }
 
 impl SendQueueData {
     /// Create the data for a send queue, in the given enabled state.
-    pub fn new(globally_enabled: bool) -> Self {
+    pub fn new(globally_enabled: bool, report_media_upload_progress: bool) -> Self {
         let (sender, _) = broadcast::channel(32);
 
         Self {
             rooms: Default::default(),
             globally_enabled: AtomicBool::new(globally_enabled),
             error_reporter: sender,
             is_dropping: Arc::new(false.into()),
+            report_media_upload_progress: Arc::new(AtomicBool::new(report_media_upload_progress)),
         }
     }
 }
@@ -389,6 +394,7 @@ impl RoomSendQueue {
         is_dropping: Arc<AtomicBool>,
         client: &Client,
         room_id: OwnedRoomId,
+        report_media_upload_progress: Arc<AtomicBool>,
     ) -> Self {
         let (updates_sender, _) = broadcast::channel(32);
 
@@ -406,6 +412,7 @@ impl RoomSendQueue {
             locally_enabled.clone(),
             global_error_reporter,
             is_dropping,
+            report_media_upload_progress,
         ));
 
         Self {
@@ -514,6 +521,7 @@ impl RoomSendQueue {
     ///
     /// It only progresses forward: nothing can be cancelled at any point, which
     /// makes the implementation not overly complicated to follow.
+    #[allow(clippy::too_many_arguments)]
     #[instrument(skip_all, fields(room_id = %room.room_id()))]
     async fn sending_task(
         room: WeakRoom,
@@ -523,6 +531,7 @@ impl RoomSendQueue {
         locally_enabled: Arc<AtomicBool>,
         global_error_reporter: broadcast::Sender<SendQueueRoomError>,
         is_dropping: Arc<AtomicBool>,
+        _report_media_upload_progress: Arc<AtomicBool>,
     ) {
         trace!("spawned the sending task");