Struct libmtp_rs::storage::StoragePool

pub struct StoragePool<'a> { /* fields omitted */ }

Represents all the storage "pool" of one MTP device, contain all the storage entries of one MTP device, and contains some methods to send or get files from the primary storage.

Implementations

impl<'a> StoragePool<'a>

pub fn by_id(&self, id: u32) -> Option<&Storage<'a>>

Returns the storage that has the given id, if there's one.

pub fn iter(&'a self) -> StoragePoolIter<'a>

Returns an iterator over the storages, this is a HashMap iterator.

pub fn files_and_folders(&self, parent: Parent) -> Vec<File<'a>>

Retrieves the contents of a certain folder (parent) in all storages, the result contains both files and folders, note that this request will always perform I/O with the device.

pub fn folder_list(&self) -> Option<Folder<'_>>

Optionally returns a Folder, with this struct you can build a tree structure (see Folder for more info)

pub fn create_folder<'b>(
    &self,
    name: &'b str,
    parent: Parent
) -> Result<(u32, Cow<'b, str>)>

Tries to create a new folder in the default storage of the relevant MtpDevice, returns the id of the new folder and its name, note that the name may be different due to device file system restrictions.

pub fn get_file_to_path<C>(
    &self,
    file: impl AsObjectId,
    path: impl AsRef<Path>,
    callback: impl Into<Option<C>>
) -> Result<()> where
    C: FnMut(u64, u64) -> CallbackReturn, 

Retrieves a file from the device storage to a local file identified by a filename, note that this is just a convenience method since it's not necessary to depend on the Storage, this is because objects have unique ids across all the device.

The callback parameter is an optional progress function with the following signature (sent_bytes: u64, total_bytes: u64) -> CallbackReturn, this way you can check the progress and if you want to cancel operation you just return CallbackReturn::Cancel.

pub fn get_file_to_descriptor<C>(
    &self,
    file: impl AsObjectId,
    descriptor: impl AsRawFd,
    callback: impl Into<Option<C>>
) -> Result<()> where
    C: FnMut(u64, u64) -> CallbackReturn, 

Retrieves a file from the device storage to a local file identified by a descriptor, note that this is just a convenience method since it's not necessary to depend on the Storage, this is because objects have unique ids across all the device.

The callback parameter is an optional progress function with the following signature (sent_bytes: u64, total_bytes: u64) -> CallbackReturn, this way you can check the progress and if you want to cancel operation you just return CallbackReturn::Cancel.

pub fn get_file_to_handler<H, C>(
    &self,
    file: impl AsObjectId,
    handler: H,
    callback: impl Into<Option<C>>
) -> Result<()> where
    H: FnMut(&[u8], &mut u32) -> HandlerReturn,
    C: FnMut(u64, u64) -> CallbackReturn, 

Retrieves a file from the device storage and calls handler with chunks of data, note that this is just a convenience method since it's not necessary to depend on the Storage, this is because objects have unique ids across all the device.

The handler parameter is the function that receives the chunks of data with the following signature (data: &[u8], read_len: &mut u32) -> HandlerReturn, where the read_len should be modified with the amount of bytes you actually read, the HandlerReturn allows you to specify if the operation was ok, had an error or if you want to cancel it.

The callback parameter is an optional progress function with the following signature (sent_bytes: u64, total_bytes: u64) -> CallbackReturn, this way you can check the progress and if you want to cancel operation you just return CallbackReturn::Cancel.

pub fn send_file_from_path<C>(
    &self,
    path: impl AsRef<Path>,
    parent: Parent,
    metadata: FileMetadata<'_>,
    callback: impl Into<Option<C>>
) -> Result<File<'a>> where
    C: FnMut(u64, u64) -> CallbackReturn, 

Sends a local file to the MTP device who this storage belongs to, note that this method will send the file to the primary storage.

The callback parameter is an optional progress function with the following signature (sent_bytes: u64, total_bytes: u64) -> CallbackReturn, this way you can check the progress and if you want to cancel operation you just return CallbackReturn::Cancel.

pub fn send_file_from_descriptor<C>(
    &self,
    descriptor: impl AsRawFd,
    parent: Parent,
    metadata: FileMetadata<'_>,
    callback: impl Into<Option<C>>
) -> Result<File<'a>> where
    C: FnMut(u64, u64) -> CallbackReturn, 

Sends a local file via descriptor to the MTP device who this storage belongs to, note that this method will send the file to the primary storage.

The callback parameter is an optional progress function with the following signature (sent_bytes: u64, total_bytes: u64) -> CallbackReturn, this way you can check the progress and if you want to cancel operation you just return CallbackReturn::Cancel.

pub fn send_file_from_handler<H, C>(
    &self,
    handler: H,
    parent: Parent,
    metadata: FileMetadata<'_>,
    callback: impl Into<Option<C>>
) -> Result<File<'a>> where
    H: FnMut(&mut [u8], &mut u32) -> HandlerReturn,
    C: FnMut(u64, u64) -> CallbackReturn, 

Sends a bunch of data to the MTP device who this storage belongs to, note that this method will send the file to primary storage.

The handler parameter is the function that receives the chunks of data with the following signature (data: &mut [u8], write_len: &mut u32) -> HandlerReturn, where the write_len should be modified with the amount of bytes you actually write, the HandlerReturn allows you to specify if the operation was ok, had an error or if you want to cancel it.

The callback parameter is an optional progress function with the following signature (sent_bytes: u64, total_bytes: u64) -> CallbackReturn, this way you can check the progress and if you want to cancel operation you just return CallbackReturn::Cancel.

Trait Implementations

impl<'a> Debug for StoragePool<'a>

fn fmt(&self, __f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.