Add the ability to turn monitors on and off

Author: ShellCode33

backlight_ipc/src/lib.rs

@@ -23,6 +23,8 @@ pub enum BacklightCommand {
     SetBrightness(u8),
     IncreaseBrightness(u8),
     DecreaseBrightness(u8),
+    TurnOffMonitors,
+    TurnOnMonitors,
     Refresh,
     SetMode(BacklightMode),
     GetInfo,

backlightctl/src/main.rs

@@ -15,6 +15,14 @@ struct BacklightctlCli {
     #[clap(short, long, default_value_t = false)]
     auto: bool,
 
+    /// Turn off monitors
+    #[clap(long, default_value_t = false)]
+    turn_off: bool,
+
+    /// Turn on monitors
+    #[clap(long, default_value_t = false)]
+    turn_on: bool,
+
     /// Refresh the list of known monitors (called by the udev rule)
     #[clap(short, long, default_value_t = false)]
     refresh: bool,
@@ -40,6 +48,15 @@ fn main() {
             .exit();
     }
 
+    if cli.turn_on && cli.turn_off {
+        BacklightctlCli::command()
+            .error(
+                ErrorKind::ArgumentConflict,
+                "You cannot use both --turn-on and --turn-off",
+            )
+            .exit();
+    }
+
     let brightness_cmd = if let Some(brightness) = cli.brightness {
         if brightness.chars().last().is_some_and(|c| c != '%') {
             BacklightctlCli::command()
@@ -163,10 +180,20 @@ fn main() {
             eprintln!("{err}");
             exit(1);
         }
+    } else if let Some(brightness_cmd) = brightness_cmd {
+        if let Err(err) = brightness_cmd.serialize_into(&stream) {
+            eprintln!("{err}");
+            exit(1);
+        }
     }
 
-    if let Some(brightness_cmd) = brightness_cmd {
-        if let Err(err) = brightness_cmd.serialize_into(&stream) {
+    if cli.turn_off {
+        if let Err(err) = BacklightCommand::TurnOffMonitors.serialize_into(&stream) {
+            eprintln!("{err}");
+            exit(1);
+        }
+    } else if cli.turn_on {
+        if let Err(err) = BacklightCommand::TurnOnMonitors.serialize_into(&stream) {
             eprintln!("{err}");
             exit(1);
         }

backlightd/src/acpi.rs

@@ -65,4 +65,12 @@ impl BacklightDevice for BacklightAcpiDevice {
         // It's ok to unwrap here, if there is no filename it means the developer did something wrong.
         self.path.file_name().unwrap().to_string_lossy().to_string()
     }
+
+    fn turn_off(&mut self) -> anyhow::Result<()> {
+        todo!()
+    }
+
+    fn turn_on(&mut self) -> anyhow::Result<()> {
+        todo!()
+    }
 }

backlightd/src/ddc.rs

@@ -1,3 +1,5 @@
+/// The bible for DDC:
+/// https://milek7.pl/ddcbacklight/mccs.pdf
 use std::error::Error;
 
 use anyhow::bail;
@@ -6,6 +8,9 @@ use ddc_hi::{Ddc, Display, FeatureCode};
 use crate::monitors::BacklightDevice;
 
 const VCP_FEATURE_BRIGHTNESS: FeatureCode = 0x10;
+const VCP_FEATURE_POWER: FeatureCode = 0xD6;
+const VCP_VALUE_POWER_ON: u16 = 0x1;
+const VCP_VALUE_POWER_OFF: u16 = 0x4;
 
 pub(crate) struct BacklightDdcDevice {
     display: Display,
@@ -57,4 +62,28 @@ impl BacklightDevice for BacklightDdcDevice {
             .clone()
             .unwrap_or(String::from("Unknown"))
     }
+
+    fn turn_off(&mut self) -> anyhow::Result<()> {
+        if let Err(err) = self
+            .display
+            .handle
+            .set_vcp_feature(VCP_FEATURE_POWER, VCP_VALUE_POWER_OFF)
+        {
+            bail!("{}: {err}", self.name());
+        }
+
+        Ok(())
+    }
+
+    fn turn_on(&mut self) -> anyhow::Result<()> {
+        if let Err(err) = self
+            .display
+            .handle
+            .set_vcp_feature(VCP_FEATURE_POWER, VCP_VALUE_POWER_ON)
+        {
+            bail!("{}: {err}", self.name());
+        }
+
+        Ok(())
+    }
 }

backlightd/src/main.rs

@@ -161,6 +161,8 @@ fn handle_client(
                 Ok(())
             }
             BacklightCommand::NotifyShutdown => break,
+            BacklightCommand::TurnOffMonitors => monitors::turn_off(),
+            BacklightCommand::TurnOnMonitors => monitors::turn_on(),
         };
 
         if let Err(err) = result {

backlightd/src/monitors.rs

@@ -24,6 +24,8 @@ pub(crate) trait BacklightDevice {
     fn name(&self) -> String;
     fn set_brightness(&mut self, percent: u8) -> anyhow::Result<()>;
     fn get_brightness(&self) -> u8;
+    fn turn_off(&mut self) -> anyhow::Result<()>;
+    fn turn_on(&mut self) -> anyhow::Result<()>;
 }
 
 pub(crate) fn auto_refresh_monitors_list() -> ! {
@@ -164,6 +166,70 @@ pub(crate) fn decrease_brightness_percent(percent: u8) -> anyhow::Result<()> {
     }
 }
 
+pub(crate) fn turn_off() -> anyhow::Result<()> {
+    let mut last_error = None;
+
+    for monitor in MONITORS.lock().unwrap().iter_mut() {
+        if let Err(err) = monitor.turn_off() {
+            log::error!("Unable to turn OFF monitor: {err}");
+            last_error = Some(err);
+        }
+    }
+
+    if last_error.is_some() {
+        log::info!("Trying to refresh monitors list to fix the error and retry...");
+        refresh_monitors_list();
+
+        last_error = None;
+        for monitor in MONITORS.lock().unwrap().iter_mut() {
+            if let Err(err) = monitor.turn_off() {
+                log::error!("Unable to turn OFF monitor: {err}");
+                last_error = Some(err);
+            }
+        }
+
+        if let Some(err) = last_error {
+            Err(err)
+        } else {
+            Ok(())
+        }
+    } else {
+        Ok(())
+    }
+}
+
+pub(crate) fn turn_on() -> anyhow::Result<()> {
+    let mut last_error = None;
+
+    for monitor in MONITORS.lock().unwrap().iter_mut() {
+        if let Err(err) = monitor.turn_on() {
+            log::error!("Unable to turn ON monitor: {err}");
+            last_error = Some(err);
+        }
+    }
+
+    if last_error.is_some() {
+        log::info!("Trying to refresh monitors list to fix the error and retry...");
+        refresh_monitors_list();
+
+        last_error = None;
+        for monitor in MONITORS.lock().unwrap().iter_mut() {
+            if let Err(err) = monitor.turn_on() {
+                log::error!("Unable to turn ON monitor: {err}");
+                last_error = Some(err);
+            }
+        }
+
+        if let Some(err) = last_error {
+            Err(err)
+        } else {
+            Ok(())
+        }
+    } else {
+        Ok(())
+    }
+}
+
 pub(crate) fn get_average_brightness() -> u8 {
     let monitors = MONITORS.lock().unwrap();
     let mut sum: usize = 0;