example/
example.rs

1use fwupd_dbus::{Client, Signal};
2use std::{
3    error::Error,
4    process,
5    sync::{
6        atomic::{AtomicBool, Ordering},
7        Arc,
8    },
9    thread,
10    time::Duration,
11};
12
13fn main() {
14    if let Err(why) = main_() {
15        let mut error = format!("error: {}", why);
16        let mut cause = why.source();
17        while let Some(why) = cause {
18            error.push_str(&format!("\n    caused by: {}", why));
19            cause = why.source();
20        }
21
22        eprintln!("{}", error);
23        process::exit(1);
24    }
25}
26
27fn main_() -> Result<(), Box<dyn Error>> {
28    // Atomic value used to stop the background thread.
29    let cancellable = Arc::new(AtomicBool::new(true));
30
31    // Begin listening to signals in the background
32    listen_in_background(cancellable.clone());
33
34    // Create a new dbus client connection.
35    let fwupd = &Client::new()?;
36
37    println!("Version: {}", fwupd.daemon_version()?);
38    println!("Status: {:?}", fwupd.status()?);
39    println!("Tainted: {}", fwupd.tainted()?);
40    if let Ok(percent) = fwupd.percentage() {
41        println!("Percentage; {}", percent);
42    }
43
44    // Fetch a list of supported devices.
45    for device in fwupd.devices()? {
46        println!("Device: {:#?}", device);
47
48        if device.is_updateable() {
49            if let Ok(upgrades) = fwupd.upgrades(&device) {
50                println!("  upgrades found");
51                for upgrade in upgrades {
52                    println!("{:#?}", upgrade);
53                }
54            } else {
55                println!("  no updates available");
56            }
57
58            if let Ok(downgrades) = fwupd.downgrades(&device) {
59                println!("  downgrades found");
60                for downgrade in downgrades {
61                    println!("{:#?}", downgrade);
62                }
63            }
64
65            if let Ok(releases) = fwupd.releases(&device) {
66                println!("   releases found");
67                for release in releases {
68                    println!("{:#?}", release);
69                }
70            }
71        } else {
72            println!("  device not updateable");
73        }
74    }
75
76    // Fetch a list of remotes, and update them.
77    for remote in fwupd.remotes()? {
78        println!("{:#?}", remote);
79
80        remote.update_metadata(fwupd)?;
81    }
82
83    loop {
84        std::thread::sleep(Duration::from_secs(1));
85    }
86
87    // Stop listening to signals in the background.
88    cancellable.store(true, Ordering::SeqCst);
89
90    Ok(())
91}
92
93fn listen_in_background(cancellable: Arc<AtomicBool>) {
94    thread::spawn(move || {
95        if let Ok(fwupd) = Client::new() {
96            // Listen for signals received by the daemon.
97            let signals = fwupd.listen_signals(cancellable).unwrap();
98            for signal in signals {
99                match signal {
100                    Signal::Changed => {
101                        println!("changed");
102                    }
103                    Signal::DeviceAdded(device) => {
104                        println!("device added: {:?}", device);
105                    }
106                    Signal::DeviceChanged(device) => {
107                        println!("device changed: {:?}", device);
108                    }
109                    Signal::DeviceRemoved(device) => {
110                        println!("device added: {:?}", device);
111                    }
112                    Signal::DeviceRequest(request) => {
113                        println!("device request: {:?}", request);
114                    }
115                    Signal::PropertiesChanged { interface, changed, invalidated } => {
116                        println!(
117                            "Properties of {} changed:\n changed: {:?}\n invalidated: {:?}",
118                            interface, changed, invalidated
119                        );
120                    }
121                }
122            }
123        }
124
125        eprintln!("STOPPED LISTENING");
126    });
127}