Refactored config changing.

src/config/mod.rs

@@ -1,11 +1,13 @@
 mod config_error;
+mod power_scheme;
 mod state_config;
 
 use autopower_shared::logging::Logger;
 pub use config_error::ConfigError;
+pub use power_scheme::PowerScheme;
 use state_config::StateConfig;
 
-use crate::{display::RefreshRateMode, power_scheme::PowerScheme};
+use crate::display::RefreshRateMode;
 use serde::{Deserialize, Serialize};
 use std::{
     fs::File,
@@ -24,14 +26,18 @@ impl Default for PowerConfig {
     fn default() -> Self {
         Self {
             wired_config: StateConfig {
+                state_name: "Wired".to_owned(),
                 power_scheme: PowerScheme::HighPerformance,
                 change_refresh_rate: true,
                 screen_refresh_rate: RefreshRateMode::Max,
+                send_notification: true,
             },
             battery_config: StateConfig {
+                state_name: "Battery".to_owned(),
                 power_scheme: PowerScheme::Balanced,
                 change_refresh_rate: true,
                 screen_refresh_rate: RefreshRateMode::Value(60),
+                send_notification: true,
             },
         }
     }

src/config/power_scheme.rs

@@ -0,0 +1,17 @@
+use serde::{Deserialize, Serialize};
+use windows::Win32::System::SystemServices::{GUID_MIN_POWER_SAVINGS, GUID_TYPICAL_POWER_SAVINGS};
+
+#[derive(Serialize, Deserialize, Debug, Clone, Copy)]
+pub enum PowerScheme {
+    HighPerformance,
+    Balanced,
+}
+
+impl PowerScheme {
+    pub const fn to_guid(&self) -> windows::core::GUID {
+        match self {
+            Self::HighPerformance => GUID_MIN_POWER_SAVINGS,
+            Self::Balanced => GUID_TYPICAL_POWER_SAVINGS,
+        }
+    }
+}

src/config/state_config.rs

@@ -1,23 +1,37 @@
-use crate::{display::RefreshRateMode, power_scheme::PowerScheme};
+use super::PowerScheme;
+use crate::{
+    display::{set_display_refresh_rate, RefreshRateMode},
+    notification_provider::NotificationProvider,
+};
 use serde::{Deserialize, Serialize};
+use windows::Win32::System::Power::PowerSetActiveScheme;
+
+type Result<T> = crate::Result<T>; // Perhaps make a custom error in the future.
 
 #[derive(Serialize, Deserialize, Debug)]
 pub struct StateConfig {
+    pub(super) state_name: String,
     pub(super) power_scheme: PowerScheme,
     pub(super) change_refresh_rate: bool,
     pub(super) screen_refresh_rate: RefreshRateMode,
+    pub(super) send_notification: bool,
 }
 
 impl StateConfig {
-    pub fn get_power_scheme(&self) -> PowerScheme {
-        self.power_scheme
-    }
+    pub fn change_to(&self, notif_provider: &mut NotificationProvider) -> Result<()> {
+        unsafe {
+            PowerSetActiveScheme(None, Some(&self.power_scheme.to_guid())).ok()?;
+        }
 
-    pub fn should_change_refresh_rate(&self) -> bool {
-        self.change_refresh_rate
-    }
+        if self.send_notification {
+            notif_provider
+                .send_display_command("AutoPower", &format!("Switching to {}.", self.state_name))
+                .map_err(|e| format!("Could not send notification!\n{}", e))?;
+        }
 
-    pub fn get_refresh_rate(&self) -> RefreshRateMode {
-        self.screen_refresh_rate
+        if self.change_refresh_rate {
+            set_display_refresh_rate(self.screen_refresh_rate)?;
+        }
+        Ok(())
     }
 }

src/main.rs

@@ -4,7 +4,6 @@ mod config;
 mod display;
 mod handler_data;
 mod notification_provider;
-mod power_scheme;
 mod services;
 
 type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;

src/services/power_service.rs

@@ -1,7 +1,6 @@
 use super::WindowsService;
 use crate::{
-    config::PowerConfig, display::set_display_refresh_rate, handler_data::HandlerData,
-    notification_provider::NotificationProvider, power_scheme::set_power_scheme,
+    config::PowerConfig, handler_data::HandlerData, notification_provider::NotificationProvider,
 };
 use autopower_shared::{logging::Logger, winstr::to_win32_wstr};
 use std::{ffi::c_void, mem::ManuallyDrop};
@@ -77,23 +76,16 @@ impl PowerService {
     }
 
     fn handle_on_wired_power(&mut self) -> Result<()> {
-        let wired_config = self.power_config.get_wired_config();
-        set_power_scheme(
-            wired_config.get_power_scheme(),
-            self.notification_provider.as_mut().unwrap(),
-        )?;
-        if wired_config.should_change_refresh_rate() {
-            set_display_refresh_rate(wired_config.get_refresh_rate())?;
-        }
+        self.power_config
+            .get_wired_config()
+            .change_to(self.notification_provider.as_mut().unwrap())?;
         Ok(())
     }
 
     fn handle_on_battery_power(&mut self) -> Result<()> {
-        let battery_config = self.power_config.get_battery_config();
-        set_power_scheme(
-            battery_config.get_power_scheme(),
-            self.notification_provider.as_mut().unwrap(),
-        )?;
+        self.power_config
+            .get_battery_config()
+            .change_to(self.notification_provider.as_mut().unwrap())?;
         Ok(())
     }