MTP: Show live disk space for MTP volumes

vdavid · vdavid · commit b155f1f8a33e · 2026-03-18T13:19:25.000+01:00
- `get_volume_space` detects `mtp://` paths and queries the device via USB (`GetStorageInfo`) instead of falling through to NSURL/statvfs
- New `get_live_storage_space()` on `MtpConnectionManager` fetches fresh space from the device and updates the cached `MtpStorageInfo` so other consumers stay current
- Both macOS and Linux volume commands handle MTP paths
diff --git a/apps/desktop/src-tauri/src/commands/volumes.rs b/apps/desktop/src-tauri/src/commands/volumes.rs
@@ -51,7 +51,30 @@ pub async fn find_containing_volume(path: String) -> TimedOut<Option<VolumeInfo>
 
 /// Gets space information for a volume at the given path.
 /// Returns total and available bytes for the volume.
+/// For MTP paths (`mtp://`), fetches from the MTP connection manager instead of macOS NSURL.
 #[tauri::command]
 pub async fn get_volume_space(path: String) -> TimedOut<Option<VolumeSpaceInfo>> {
+    if let Some(space) = get_mtp_space_info(&path).await {
+        return TimedOut {
+            data: Some(space),
+            timed_out: false,
+        };
+    }
     blocking_with_timeout_flag(VOLUME_TIMEOUT, None, move || volumes::get_volume_space(&path)).await
 }
+
+/// Queries live MTP space info from a `mtp://{device_id}/{storage_id}/...` path.
+async fn get_mtp_space_info(path: &str) -> Option<VolumeSpaceInfo> {
+    let rest = path.strip_prefix("mtp://")?;
+    let mut parts = rest.splitn(3, '/');
+    let device_id = parts.next()?;
+    let storage_id: u32 = parts.next()?.parse().ok()?;
+
+    let (total_bytes, available_bytes) = crate::mtp::connection_manager()
+        .get_live_storage_space(device_id, storage_id)
+        .await?;
+    Some(VolumeSpaceInfo {
+        total_bytes,
+        available_bytes,
+    })
+}
diff --git a/apps/desktop/src-tauri/src/commands/volumes_linux.rs b/apps/desktop/src-tauri/src/commands/volumes_linux.rs
@@ -45,10 +45,33 @@ pub fn find_containing_volume(path: String) -> TimedOut<Option<VolumeInfo>> {
 }
 
 /// Gets space information for a volume at the given path.
+/// For MTP paths (`mtp://`), fetches from the MTP connection manager instead of statvfs.
 #[tauri::command]
-pub fn get_volume_space(path: String) -> TimedOut<Option<VolumeSpaceInfo>> {
+pub async fn get_volume_space(path: String) -> TimedOut<Option<VolumeSpaceInfo>> {
+    if let Some(space) = get_mtp_space_info(&path).await {
+        return TimedOut {
+            data: Some(space),
+            timed_out: false,
+        };
+    }
     TimedOut {
         data: volumes_linux::get_volume_space(&path),
         timed_out: false,
     }
 }
+
+/// Queries live MTP space info from a `mtp://{device_id}/{storage_id}/...` path.
+async fn get_mtp_space_info(path: &str) -> Option<VolumeSpaceInfo> {
+    let rest = path.strip_prefix("mtp://")?;
+    let mut parts = rest.splitn(3, '/');
+    let device_id = parts.next()?;
+    let storage_id: u32 = parts.next()?.parse().ok()?;
+
+    let (total_bytes, available_bytes) = crate::mtp::connection_manager()
+        .get_live_storage_space(device_id, storage_id)
+        .await?;
+    Some(VolumeSpaceInfo {
+        total_bytes,
+        available_bytes,
+    })
+}
diff --git a/apps/desktop/src-tauri/src/mtp/connection/mod.rs b/apps/desktop/src-tauri/src/mtp/connection/mod.rs
@@ -418,6 +418,57 @@ impl MtpConnectionManager {
             storages: entry.storages.clone(),
         })
     }
+
+    /// Queries live storage space from the device and updates the cache.
+    ///
+    /// Returns `(total_bytes, available_bytes)` freshly read from the device,
+    /// or `None` if the device/storage is not found or the query fails.
+    pub async fn get_live_storage_space(
+        &self,
+        device_id: &str,
+        storage_id: u32,
+    ) -> Option<(u64, u64)> {
+        let device_arc = {
+            let devices = self.devices.lock().await;
+            devices.get(device_id)?.device.clone()
+        };
+
+        let device = match acquire_device_lock(&device_arc, device_id, "get_live_storage_space").await {
+            Ok(d) => d,
+            Err(e) => {
+                warn!("get_live_storage_space: failed to acquire lock: {:?}", e);
+                return None;
+            }
+        };
+
+        let mtp_storage_id = mtp_rs::ptp::StorageId(storage_id);
+        let storage = match device.storage(mtp_storage_id).await {
+            Ok(s) => s,
+            Err(e) => {
+                warn!("get_live_storage_space: failed to query storage {}: {:?}", storage_id, e);
+                return None;
+            }
+        };
+        let info = storage.info();
+        let total = info.max_capacity;
+        let available = info.free_space_bytes;
+
+        // Release the device lock before updating the cache
+        drop(device);
+
+        // Update cache so other consumers (e.g. volume breadcrumb) see fresh data too
+        {
+            let mut devices = self.devices.lock().await;
+            if let Some(entry) = devices.get_mut(device_id) {
+                if let Some(cached) = entry.storages.iter_mut().find(|s| s.id == storage_id) {
+                    cached.total_bytes = total;
+                    cached.available_bytes = available;
+                }
+            }
+        }
+
+        Some((total, available))
+    }
 }
 
 // Remaining impl blocks are in submodules:
