Struct DeviceWatch 

pub struct DeviceWatch { /* private fields */ }

A stream of HotplugEvents reporting MTP devices arriving and leaving.

Build one with watch_devices or DeviceWatchBuilder. Only devices that MtpDevice::list_devices would list produce events; mice, hubs, and chargers never reach the consumer.

use futures::StreamExt;
use mtp_rs::mtp::{watch_devices, HotplugEvent, MtpDevice};

let mut watch = watch_devices()?;
while let Some(event) = watch.next().await {
    match event {
        HotplugEvent::Arrived(info) => {
            let serial = info.serial_number.clone().unwrap_or_default();
            let device = MtpDevice::open_by_serial(&serial).await?;
            println!("mounted {}", device.device_info().model);
        }
        HotplugEvent::Left(info) => println!("gone: {:?}", info.serial_number),
    }
}

What the stream guarantees

• Devices already plugged in when watching starts arrive as HotplugEvent::Arrived, before any live event. So a consumer needs one code path, not an enumerate-then-watch pair, and a device plugged in during startup can’t slip through the gap between the two. Consumers must not enumerate separately as well, or they’ll count those devices twice.
• HotplugEvent::Left carries the full MtpDeviceInfo of the device that went away, including its serial. The OS reports only an opaque id on disconnect, so the watch caches what it last saw; without that a consumer can’t tell which of two phones was unplugged.
• A device that changes identity in place (a phone switching from charge-only to file transfer, which re-enumerates it with new descriptors) is reported as a Left for the old identity followed by an Arrived for the new one.
• The stream never ends on its own; it stays live until dropped. Dropping it stops the notifications and any later device changes are missed, so a consumer tracking devices for the lifetime of a process should hold it for that long.

Scope

USB only. Virtual devices (feature virtual-device) are registered in-process rather than plugged in, so they never produce hotplug events even though list_devices includes them.

The watch reports device presence; it does not open anything. A device that has just arrived may still refuse to open a session for a moment, and on Android the user may not have granted file-transfer mode yet. Retry with backoff rather than treating the first failure as fatal.

Trait Implementations

impl Debug for DeviceWatch

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

Formats the value using the given formatter.

impl Stream for DeviceWatch

type Item = HotplugEvent

Values yielded by the stream.

fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Option<Self::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.