Struct Storage 

pub struct Storage { /* private fields */ }

A storage location on an MTP device.

Storage holds an Arc<MtpDeviceInner> so it can outlive the original MtpDevice and be used from multiple tasks.

Implementations

impl Storage

pub fn id(&self) -> StorageId

pub fn info(&self) -> &StorageInfo

Storage information (cached, call refresh() to update).

pub async fn refresh(&mut self) -> Result<(), Error>

Refresh storage info from device (updates free space, etc.).

pub async fn list_objects( &self, parent: Option<ObjectHandle>, ) -> Result<Vec<ObjectInfo>, Error>

List objects in a folder (None = root), returning all results at once.

For progress reporting during large listings, use list_objects_stream() instead.

This method handles various device quirks:

• Android devices: parent=0 returns ALL objects, so we use parent=0xFFFFFFFF instead
• Samsung devices: return InvalidObjectHandle for parent=0, so we fall back to recursive
• Fuji devices: return all objects for root, so we filter by parent handle

pub async fn list_objects_stream( &self, parent: Option<ObjectHandle>, ) -> Result<ObjectListing, Error>

List objects in a folder as a streaming ObjectListing.

Returns immediately after GetObjectHandles completes (one USB round-trip). The total count is then known via ObjectListing::total(), and each call to ObjectListing::next() fetches one object’s metadata from USB.

This enables progress reporting (e.g., “Loading 42 of 500…”) during what would otherwise be a single blocking list_objects() call.

Handles the same device quirks as list_objects().

Example

let mut listing = storage.list_objects_stream(None).await?;
println!("Found {} items", listing.total());

while let Some(result) = listing.next().await {
    let info = result?;
    println!("[{}/{}] {}", listing.fetched(), listing.total(), info.filename);
}

pub async fn list_objects_recursive( &self, parent: Option<ObjectHandle>, ) -> Result<Vec<ObjectInfo>, Error>

List objects recursively.

This method automatically detects Android devices and uses manual traversal for them, since Android’s MTP implementation doesn’t support the native ObjectHandle::ALL recursive listing.

For non-Android devices, it tries native recursive listing first and falls back to manual traversal if the results look incomplete.

pub async fn list_objects_recursive_native( &self, parent: Option<ObjectHandle>, ) -> Result<Vec<ObjectInfo>, Error>

List objects recursively using native MTP recursive listing.

pub async fn list_objects_recursive_manual( &self, parent: Option<ObjectHandle>, ) -> Result<Vec<ObjectInfo>, Error>

List objects recursively using manual folder traversal.

pub async fn get_object_info( &self, handle: ObjectHandle, ) -> Result<ObjectInfo, Error>

Get object metadata by handle.

pub async fn download(&self, handle: ObjectHandle) -> Result<Vec<u8>, Error>

Download a file and return all bytes.

For small to medium files where you want all the data in memory. For large files or streaming to disk, use download_stream().

pub async fn download_partial( &self, handle: ObjectHandle, offset: u64, size: u32, ) -> Result<Vec<u8>, Error>

Download a partial file (byte range).

pub async fn download_thumbnail( &self, handle: ObjectHandle, ) -> Result<Vec<u8>, Error>

pub async fn download_stream( &self, handle: ObjectHandle, ) -> Result<FileDownload, Error>

Download a file as a stream (true USB streaming).

Unlike download(), this method yields data chunks directly from USB as they arrive, without buffering the entire file in memory. Ideal for large files or when piping data to disk.

Important

The MTP session is locked while the download is active. You must consume the entire download (or drop it) before calling other storage methods.

Example

let mut download = storage.download_stream(handle).await?;
println!("Downloading {} bytes...", download.size());

let mut file = tokio::fs::File::create("output.bin").await?;
while let Some(chunk) = download.next_chunk().await {
    let bytes = chunk?;
    file.write_all(&bytes).await?;
    println!("Progress: {:.1}%", download.progress() * 100.0);
}

pub async fn upload<S>( &self, parent: Option<ObjectHandle>, info: NewObjectInfo, data: S, ) -> Result<ObjectHandle, Error>

where S: Stream<Item = Result<Bytes, Error>> + Unpin,

Upload a file from a stream.

The stream is consumed and all data is buffered before sending (MTP protocol requires knowing the total size upfront).

Arguments

• parent - Parent folder handle (None for root)
• info - Object metadata including filename and size
• data - Stream of data chunks to upload

pub async fn upload_with_progress<S, F>( &self, parent: Option<ObjectHandle>, info: NewObjectInfo, data: S, on_progress: F, ) -> Result<ObjectHandle, Error>

where S: Stream<Item = Result<Bytes, Error>> + Unpin, F: FnMut(Progress) -> ControlFlow<()>,

Upload a file with progress callback.

Progress is reported as data is read from the stream. Return ControlFlow::Break(()) from the callback to cancel the upload.

pub async fn create_folder( &self, parent: Option<ObjectHandle>, name: &str, ) -> Result<ObjectHandle, Error>

pub async fn delete(&self, handle: ObjectHandle) -> Result<(), Error>

pub async fn move_object( &self, handle: ObjectHandle, new_parent: ObjectHandle, new_storage: Option<StorageId>, ) -> Result<(), Error>

Move an object to a different folder.

pub async fn copy_object( &self, handle: ObjectHandle, new_parent: ObjectHandle, new_storage: Option<StorageId>, ) -> Result<ObjectHandle, Error>

pub async fn rename( &self, handle: ObjectHandle, new_name: &str, ) -> Result<(), Error>

Rename an object (file or folder).

Not all devices support renaming. Use MtpDevice::supports_rename() to check if this operation is available.