updating option "-k" to show current brightness: asusctl -k

asus-nb-ctrl/src/ctrl_leds.rs

@@ -98,6 +98,16 @@ impl DbusKbdBacklight {
         "SetKeyBacklight could not deserialise".to_string()
     }
 
+    fn led_bright(&self) -> i8 {
+        if let Ok(ctrl) = self.inner.try_lock() {
+            if let Ok(cfg) = ctrl.config.clone().try_lock() {
+                return cfg.kbd_led_brightness as i8;
+            }
+        }
+        warn!("SetKeyBacklight could not deserialise");
+        -1
+    }
+
     #[dbus_interface(signal)]
     fn notify_led(&self, data: &str) -> zbus::Result<()>;
 }

asus-nb-ctrl/src/main.rs

@@ -6,16 +6,22 @@ use asus_nb::{
 };
 use ctrl_gfx::vendors::GfxVendors;
 use daemon::ctrl_fan_cpu::FanLevel;
-use gumdrop::Options;
+use gumdrop::{
+    Opt,
+    Options,
+};
 use log::LevelFilter;
-use std::io::Write;
+use std::{
-use std::process::Command;
+    env::args,
+    io::Write,
+    process::Command,
+};
 use yansi_term::Colour::Green;
 use yansi_term::Colour::Red;
 
-#[derive(Options)]
+#[derive(Default, Options)]
 struct CLIStart {
-    #[options(help = "print help message")]
+    #[options(help_flag, help = "print help message")]
     help: bool,
     #[options(help = "show program version number")]
     version: bool,
@@ -79,7 +85,32 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         .filter(None, LevelFilter::Info)
         .init();
 
-    let parsed = CLIStart::parse_args_default_or_exit();
+    let mut args : Vec<String> = args().collect();
+    args.remove(0);
+
+    let parsed : CLIStart;
+    let missing_argument_k = gumdrop::Error::missing_argument(Opt::Short('k'));
+    match CLIStart::parse_args_default(&args) {
+        Ok(p) => {
+            parsed = p;
+        }
+        Err(err) if err.to_string() == missing_argument_k.to_string() => {
+            parsed = CLIStart {
+                kbd_bright: Some(LedBrightness::new(None)),
+                ..Default::default()
+            };
+        }
+        Err(err) => {
+            eprintln!("source {:?}", err);
+            std::process::exit(2);
+        }
+    }
+
+    if parsed.help_requested() {
+        // As help option don't work with `parse_args_default`
+        // we will call `parse_args_default_or_exit` instead
+        CLIStart::parse_args_default_or_exit();
+    }
 
     if parsed.version {
         println!("Version: {}", daemon::VERSION);
@@ -109,8 +140,16 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     }
 
     if let Some(brightness) = parsed.kbd_bright {
-        writer.write_brightness(brightness.level())?;
+        match brightness.level() {
+            None => {
+                let level = writer.get_led_brightness()?;
+                println!("Current keyboard led brightness: {}",
+                         level.to_string());
+            },
+            Some(level) => writer.write_brightness(level)?,
+        }
     }
+
     if let Some(fan_level) = parsed.pwr_profile {
         writer.write_fan_mode(fan_level.into())?;
     }

asus-nb/src/cli_options.rs

@@ -5,10 +5,14 @@ use std::str::FromStr;
 
 #[derive(Options)]
 pub struct LedBrightness {
-    level: u8,
+    level: Option<u8>,
 }
 impl LedBrightness {
-    pub fn level(&self) -> u8 {
+    pub fn new(level: Option<u8>) -> Self {
+        LedBrightness { level }
+    }
+
+    pub fn level(&self) -> Option<u8> {
         self.level
     }
 }
@@ -18,17 +22,30 @@ impl FromStr for LedBrightness {
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let s = s.to_lowercase();
         match s.as_str() {
-            "off" => Ok(LedBrightness { level: 0x00 }),
+            "off" => Ok(LedBrightness { level: Some(0x00) }),
-            "low" => Ok(LedBrightness { level: 0x01 }),
+            "low" => Ok(LedBrightness { level: Some(0x01) }),
-            "med" => Ok(LedBrightness { level: 0x02 }),
+            "med" => Ok(LedBrightness { level: Some(0x02) }),
-            "high" => Ok(LedBrightness { level: 0x03 }),
+            "high" => Ok(LedBrightness { level: Some(0x03) }),
             _ => {
-                println!("Missing required argument, must be one of:\noff,low,med,high\n");
+                print!("{}\n{}\n",
+                       "Invalid argument, must be one of:",
+                       "off, low, med, high");
                 Err(AuraError::ParseBrightness)
             }
         }
     }
 }
+impl ToString for LedBrightness {
+    fn to_string(&self) -> String {
+        let s = match self.level {
+            Some(0x00) => "low",
+            Some(0x01) => "med",
+            Some(0x02) => "high",
+            _ => "unknown",
+        };
+        s.to_string()
+    }
+}
 
 #[derive(Deserialize, Serialize)]
 pub struct Colour(pub u8, pub u8, pub u8);

asus-nb/src/core_dbus.rs

@@ -1,3 +1,4 @@
+use crate::cli_options::LedBrightness;
 use super::*;
 use crate::fancy::KeyColourArray;
 use crate::profile::ProfileEvent;
@@ -305,8 +306,21 @@ impl AuraDbusClient {
     }
 
     #[inline]
-    pub fn write_brightness(&self, level: u8) -> Result<String, Box<dyn std::error::Error>> {
+    pub fn get_led_brightness(&self) -> Result<LedBrightness, Box<dyn Error>> {
+        let proxy = self.connection.with_proxy(
+            "org.asuslinux.Daemon",
+            "/org/asuslinux/Led",
+            Duration::from_secs(2),
+        );
+        match proxy.led_bright()? {
+            -1 => Ok(LedBrightness::new(None)),
+            level => Ok(LedBrightness::new(Some(level as u8))),
+        }
+    }
+
+    #[inline]
+    pub fn write_brightness(&self, level: u8) -> Result<(), Box<dyn std::error::Error>> {
         self.write_keyboard_leds(&AuraModes::LedBrightness(level))?;
-        Ok(String::new())
+        Ok(())
     }
 }

asus-nb/src/dbus_ledmode.rs

@@ -8,6 +8,7 @@ pub trait OrgAsuslinuxDaemon {
     fn set_led_mode(&self, data: &str) -> Result<(), dbus::Error>;
     fn led_mode(&self) -> Result<String, dbus::Error>;
     fn led_modes(&self) -> Result<String, dbus::Error>;
+    fn led_bright(&self) -> Result<i16, dbus::Error>;
 }
 
 impl<'a, T: blocking::BlockingSender, C: ::std::ops::Deref<Target=T>> OrgAsuslinuxDaemon for blocking::Proxy<'a, C> {
@@ -25,6 +26,11 @@ impl<'a, T: blocking::BlockingSender, C: ::std::ops::Deref<Target=T>> OrgAsuslin
         self.method_call("org.asuslinux.Daemon", "LedModes", ())
             .and_then(|r: (String, )| Ok(r.0, ))
     }
+
+    fn led_bright(&self) -> Result<i16, dbus::Error> {
+        self.method_call("org.asuslinux.Daemon", "LedBright", ())
+            .and_then(|r: (i16, )| Ok(r.0, ))
+    }
 }
 
 #[derive(Debug)]