Switch from percentage progress to abstract current / total progress

Author: Johennes

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

@@ -218,16 +218,21 @@ impl From<matrix_sdk::TransmissionProgress> for TransmissionProgress {
     }
 }
 
-/// Progress of sending or receiving a payload in percent.
+/// Progress of an operation in abstract units.
 #[derive(Clone, Copy, uniffi::Record)]
-pub struct RelativeTransmissionProgress {
-    /// The completion percentage as a number between 0 and 1.
-    pub percentage: f32,
+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::RelativeTransmissionProgress> for RelativeTransmissionProgress {
-    fn from(value: matrix_sdk::RelativeTransmissionProgress) -> Self {
-        Self { percentage: value.percentage }
+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),
+        }
     }
 }
 

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

@@ -67,7 +67,7 @@ use uuid::Uuid;
 use self::content::TimelineItemContent;
 pub use self::msg_like::MessageContent;
 use crate::{
-    client::{ProgressWatcher, RelativeTransmissionProgress},
+    client::{AbstractProgress, ProgressWatcher},
     error::{ClientError, RoomError},
     event::EventOrTransactionId,
     helpers::unwrap_or_clone_arc,
@@ -280,7 +280,7 @@ pub enum EventSendProgress {
 
         /// The current combined upload progress for both the file and,
         /// if it exists, its thumbnail.
-        progress: RelativeTransmissionProgress,
+        progress: AbstractProgress,
     },
 }
 

crates/matrix-sdk-ui/src/timeline/event_item/local.rs

@@ -15,7 +15,7 @@
 use std::sync::Arc;
 
 use as_variant::as_variant;
-use matrix_sdk::{send_queue::SendHandle, Error, RelativeTransmissionProgress};
+use matrix_sdk::{send_queue::SendHandle, AbstractProgress, Error};
 use ruma::{EventId, OwnedEventId, OwnedTransactionId};
 
 use super::TimelineEventItemId;

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

@@ -231,11 +231,13 @@ pub struct TransmissionProgress {
     pub total: usize,
 }
 
-/// Progress of sending or receiving a payload in percent.
+/// Progress of an operation in abstract units.
 #[derive(Clone, Copy, Debug, Default)]
-pub struct RelativeTransmissionProgress {
-    /// The completion percentage as a number between 0 and 1.
-    pub percentage: f32,
+pub struct AbstractProgress {
+    /// How many units were already transferred.
+    pub current: usize,
+    /// How many units there are in total.
+    pub total: usize,
 }
 
 async fn response_to_http_response(

crates/matrix-sdk/src/lib.rs

@@ -72,7 +72,7 @@ pub use error::{
     Error, HttpError, HttpResult, NotificationSettingsError, RefreshTokenError, Result,
     RumaApiError,
 };
-pub use http_client::{RelativeTransmissionProgress, TransmissionProgress};
+pub use http_client::{AbstractProgress, TransmissionProgress};
 #[cfg(all(feature = "e2e-encryption", feature = "sqlite"))]
 pub use matrix_sdk_sqlite::SqliteCryptoStore;
 #[cfg(feature = "sqlite")]

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

@@ -177,7 +177,7 @@ use crate::{
     config::RequestConfig,
     error::RetryKind,
     room::{edit::EditedContent, WeakRoom},
-    Client, Media, RelativeTransmissionProgress, Room, TransmissionProgress,
+    AbstractProgress, Client, Media, Room, TransmissionProgress,
 };
 
 mod upload;
@@ -910,18 +910,21 @@ fn compute_combined_progress(
     file_size: usize,
     thumbnail_file_size: Option<usize>,
     media_file_size: Option<usize>,
-) -> RelativeTransmissionProgress {
-    let percentage = if progress.total != 0 {
+) -> AbstractProgress {
+    if progress.total == 0 {
+        AbstractProgress { current: 0, total: 0 }
+    } else {
         // The uploaded file is possibly encrypted and, thus, larger than
         // the original one. Use the rule of 3 to proportionally map the
         // progress into units of the original file size.
-        let mut current = progress.current as f32 / progress.total as f32 * file_size as f32;
+        let mut current =
+            (progress.current as f32 / progress.total as f32 * file_size as f32).round() as usize;
         let mut total = file_size;
 
         // If a thumbnail was previously uploaded, add its file size to both
         // the current and total.
         if let Some(thumbnail_file_size) = thumbnail_file_size {
-            current += thumbnail_file_size as f32;
+            current += thumbnail_file_size;
             total += thumbnail_file_size;
         }
 
@@ -931,16 +934,8 @@ fn compute_combined_progress(
             total += media_file_size;
         }
 
-        if total != 0 {
-            current / total as f32
-        } else {
-            0.0
-        }
-    } else {
-        0.0
-    };
-
-    RelativeTransmissionProgress { percentage }
+        AbstractProgress { current, total }
+    }
 }
 
 impl From<&crate::Error> for QueueWedgeError {