Struct Device

pub struct Device {

    pub checksum: Option<Box<str>>,
    pub created: u64,
    pub description: Option<Box<str>>,
    pub device_id: DeviceId,
    pub flags: DeviceFlags,
    pub flashes_left: Option<u32>,
    pub guid: Box<[Box<str>]>,
    pub icon: Box<[Box<str>]>,
    pub install_duration: Option<u32>,
    pub instance_ids: Box<[Box<str>]>,
    pub modified: Option<u64>,
    pub name: Box<str>,
    pub parent_device_id: Option<DeviceId>,
    pub plugin: Box<str>,
    pub serial: Option<Box<str>>,
    pub summary: Option<Box<str>>,
    pub update_error: Option<Box<str>>,
    pub update_message: Option<Box<str>>,
    pub update_state: Option<UpdateState>,
    pub vendor_id: Box<str>,
    pub vendor: Box<str>,
    pub version_bootloader: Option<Box<str>>,
    pub version_format: Option<VersionFormat>,
    pub version_lowest: Option<Box<str>>,
    pub version: Box<str>,
}

A device that is potentially-supported by fwupd.

Fields

checksum: Option<Box<str>>

created: u64

description: Option<Box<str>>

device_id: DeviceId

flags: DeviceFlags

flashes_left: Option<u32>

guid: Box<[Box<str>]>

icon: Box<[Box<str>]>

install_duration: Option<u32>

instance_ids: Box<[Box<str>]>

modified: Option<u64>

name: Box<str>

parent_device_id: Option<DeviceId>

plugin: Box<str>

serial: Option<Box<str>>

summary: Option<Box<str>>

update_error: Option<Box<str>>

update_message: Option<Box<str>>

update_state: Option<UpdateState>

vendor_id: Box<str>

vendor: Box<str>

version_bootloader: Option<Box<str>>

version_format: Option<VersionFormat>

version_lowest: Option<Box<str>>

version: Box<str>

Implementations

impl Device

pub fn has_flag(&self, flags: DeviceFlags) -> bool

Check if the given DeviceFlag is set.

pub fn has_guid(&self, guid: &str) -> bool

Returns true if a GUID match was found.

pub fn is_supported(&self) -> bool

Checks if the device is supported by fwupd.

pub fn is_updateable(&self) -> bool

Determins if the device is updateable or not.

Examples found in repository

examples/example.rs (line 48)

fn main_() -> Result<(), Box<dyn Error>> {
    // Atomic value used to stop the background thread.
    let cancellable = Arc::new(AtomicBool::new(true));

    // Begin listening to signals in the background
    listen_in_background(cancellable.clone());

    // Create a new dbus client connection.
    let fwupd = &Client::new()?;

    println!("Version: {}", fwupd.daemon_version()?);
    println!("Status: {:?}", fwupd.status()?);
    println!("Tainted: {}", fwupd.tainted()?);
    if let Ok(percent) = fwupd.percentage() {
        println!("Percentage; {}", percent);
    }

    // Fetch a list of supported devices.
    for device in fwupd.devices()? {
        println!("Device: {:#?}", device);

        if device.is_updateable() {
            if let Ok(upgrades) = fwupd.upgrades(&device) {
                println!("  upgrades found");
                for upgrade in upgrades {
                    println!("{:#?}", upgrade);
                }
            } else {
                println!("  no updates available");
            }

            if let Ok(downgrades) = fwupd.downgrades(&device) {
                println!("  downgrades found");
                for downgrade in downgrades {
                    println!("{:#?}", downgrade);
                }
            }

            if let Ok(releases) = fwupd.releases(&device) {
                println!("   releases found");
                for release in releases {
                    println!("{:#?}", release);
                }
            }
        } else {
            println!("  device not updateable");
        }
    }

    // Fetch a list of remotes, and update them.
    for remote in fwupd.remotes()? {
        println!("{:#?}", remote);

        remote.update_metadata(fwupd)?;
    }

    loop {
        std::thread::sleep(Duration::from_secs(1));
    }

    // Stop listening to signals in the background.
    cancellable.store(true, Ordering::SeqCst);

    Ok(())
}

pub fn needs_reboot(&self) -> bool

Checks if the device requires a reboot.

pub fn only_offline(&self) -> bool

Check if the device must be updated offline.

Trait Implementations

impl AsRef<DeviceId> for Device

fn as_ref(&self) -> &DeviceId

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Device

fn clone(&self) -> Device

Returns a duplicate of the value.

const fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Device

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

Formats the value using the given formatter.

impl Default for Device

fn default() -> Device

Returns the “default value” for a type.

impl FromIterator<(String, Variant<Box<dyn RefArg>>)> for Device

fn from_iter<T>(iter: T) -> Self

where T: IntoIterator<Item = DBusEntry>,

Creates a value from an iterator.