Add verbose output for fan-curve detection. Add mocking to GUI.

asusd: Verbose output of fan-curves on startup
ROGCC: Try to mock more of GUI state

rog-control-center/src/mocking.rs

@@ -0,0 +1,225 @@
+use std::collections::BTreeMap;
+
+use rog_aura::{
+    usb::{AuraDev19b6, AuraDevice, AuraPowerDev},
+    AuraEffect, AuraModeNum, AuraZone,
+};
+use rog_profiles::fan_curve_set::{CurveData, FanCurveSet};
+use rog_supported::{
+    AnimeSupportedFunctions, ChargeSupportedFunctions, LedSupportedFunctions,
+    PlatformProfileFunctions, RogBiosSupportedFunctions, SupportedFunctions,
+};
+
+use crate::error::Result;
+
+const NOPE: &'static str = "";
+
+pub struct RogDbusClientBlocking<'a> {
+    _phantom: &'a str,
+}
+
+impl<'a> Default for RogDbusClientBlocking<'a> {
+    fn default() -> Self {
+        Self {
+            _phantom: Default::default(),
+        }
+    }
+}
+
+impl<'a> RogDbusClientBlocking<'a> {
+    pub fn new() -> Result<(Self, bool)> {
+        Ok((Self { _phantom: NOPE }, true))
+    }
+    pub fn proxies(&self) -> Proxies {
+        Proxies
+    }
+}
+
+pub struct Proxies;
+impl Proxies {
+    pub fn rog_bios(&self) -> Bios {
+        Bios
+    }
+    pub fn profile(&self) -> Profile {
+        Profile
+    }
+    pub fn led(&self) -> Led {
+        Led
+    }
+    pub fn anime(&self) -> Anime {
+        Anime
+    }
+    pub fn charge(&self) -> Profile {
+        Profile
+    }
+    pub fn supported(&self) -> Supported {
+        Supported
+    }
+}
+
+pub struct Bios;
+impl Bios {
+    pub fn post_boot_sound(&self) -> Result<i16> {
+        Ok(1)
+    }
+    pub fn dedicated_graphic_mode(&self) -> Result<i16> {
+        Ok(1)
+    }
+    pub fn panel_overdrive(&self) -> Result<i16> {
+        Ok(1)
+    }
+    pub fn set_post_boot_sound(&self, _b: bool) -> Result<()> {
+        Ok(())
+    }
+    pub fn set_dedicated_graphic_mode(&self, _b: bool) -> Result<()> {
+        Ok(())
+    }
+    pub fn set_panel_overdrive(&self, _b: bool) -> Result<()> {
+        Ok(())
+    }
+}
+
+pub struct Profile;
+impl Profile {
+    pub fn profiles(&self) -> Result<Vec<rog_profiles::Profile>> {
+        Ok(vec![
+            rog_profiles::Profile::Balanced,
+            rog_profiles::Profile::Performance,
+            rog_profiles::Profile::Quiet,
+        ])
+    }
+    pub fn active_profile(&self) -> Result<rog_profiles::Profile> {
+        Ok(rog_profiles::Profile::Performance)
+    }
+    pub fn enabled_fan_profiles(&self) -> Result<Vec<rog_profiles::Profile>> {
+        Ok(vec![
+            rog_profiles::Profile::Performance,
+            rog_profiles::Profile::Balanced,
+        ])
+    }
+    pub fn fan_curve_data(&self, _p: rog_profiles::Profile) -> Result<FanCurveSet> {
+        let mut curve = FanCurveSet::default();
+        curve.cpu.pwm = [30, 40, 60, 100, 140, 180, 200, 250];
+        curve.cpu.temp = [20, 30, 40, 50, 70, 80, 90, 100];
+        curve.gpu.pwm = [40, 80, 100, 140, 170, 200, 230, 250];
+        curve.gpu.temp = [20, 30, 40, 50, 70, 80, 90, 100];
+        Ok(curve)
+    }
+    pub fn set_fan_curve(&self, _p: rog_profiles::Profile, _c: CurveData) -> Result<()> {
+        Ok(())
+    }
+    pub fn set_fan_curve_enabled(&self, _p: rog_profiles::Profile, _b: bool) -> Result<()> {
+        Ok(())
+    }
+    pub fn limit(&self) -> Result<i16> {
+        Ok(66)
+    }
+    pub fn set_limit(&self, _l: u8) -> Result<()> {
+        Ok(())
+    }
+    pub fn set_active_profile(&self, _p: rog_profiles::Profile) -> Result<()> {
+        Ok(())
+    }
+}
+
+pub struct Led;
+impl Led {
+    pub fn led_modes(&self) -> Result<BTreeMap<AuraModeNum, AuraEffect>> {
+        let mut data = BTreeMap::new();
+        data.insert(AuraModeNum::Static, AuraEffect::default());
+        data.insert(AuraModeNum::Star, AuraEffect::default());
+        data.insert(AuraModeNum::Strobe, AuraEffect::default());
+        data.insert(AuraModeNum::Rain, AuraEffect::default());
+        data.insert(AuraModeNum::Rainbow, AuraEffect::default());
+        data.insert(AuraModeNum::Ripple, AuraEffect::default());
+        data.insert(AuraModeNum::Breathe, AuraEffect::default());
+        data.insert(AuraModeNum::Comet, AuraEffect::default());
+        data.insert(AuraModeNum::Flash, AuraEffect::default());
+        data.insert(AuraModeNum::Laser, AuraEffect::default());
+        data.insert(AuraModeNum::Pulse, AuraEffect::default());
+        Ok(data)
+    }
+    pub fn led_mode(&self) -> Result<AuraModeNum> {
+        Ok(AuraModeNum::Rainbow)
+    }
+    pub fn led_brightness(&self) -> Result<i16> {
+        Ok(1)
+    }
+    pub fn leds_enabled(&self) -> Result<AuraPowerDev> {
+        Ok(AuraPowerDev {
+            x1866: vec![],
+            x19b6: vec![
+                AuraDev19b6::BootKeyb,
+                AuraDev19b6::AwakeKeyb,
+                AuraDev19b6::SleepLogo,
+                AuraDev19b6::AwakeLogo,
+            ],
+        })
+    }
+    pub fn set_leds_power(&self, _a: AuraPowerDev, _b: bool) -> Result<()> {
+        Ok(())
+    }
+    pub fn set_led_mode(&self, _a: &AuraEffect) -> Result<()> {
+        Ok(())
+    }
+}
+
+pub struct Anime;
+impl Anime {
+    pub fn boot_enabled(&self) -> Result<bool> {
+        Ok(true)
+    }
+    pub fn awake_enabled(&self) -> Result<bool> {
+        Ok(true)
+    }
+    pub fn set_on_off(&self, _b: bool) -> Result<()> {
+        Ok(())
+    }
+    pub fn set_boot_on_off(&self, _b: bool) -> Result<()> {
+        Ok(())
+    }
+}
+
+pub struct Supported;
+impl Supported {
+    pub fn supported_functions(&self) -> Result<SupportedFunctions> {
+        Ok(SupportedFunctions {
+            anime_ctrl: AnimeSupportedFunctions(true),
+            charge_ctrl: ChargeSupportedFunctions {
+                charge_level_set: true,
+            },
+            platform_profile: PlatformProfileFunctions {
+                platform_profile: true,
+                fan_curves: true,
+            },
+            keyboard_led: LedSupportedFunctions {
+                prod_id: AuraDevice::X19B6,
+                brightness_set: true,
+                stock_led_modes: vec![
+                    AuraModeNum::Rain,
+                    AuraModeNum::Rainbow,
+                    AuraModeNum::Star,
+                    AuraModeNum::Static,
+                    AuraModeNum::Strobe,
+                ],
+                multizone_led_mode: vec![
+                    AuraZone::Key1,
+                    AuraZone::Key2,
+                    AuraZone::Key3,
+                    AuraZone::Key4,
+                    AuraZone::BarLeft,
+                    AuraZone::BarRight,
+                    AuraZone::Logo,
+                ],
+                per_key_led_mode: true,
+            },
+            rog_bios_ctrl: RogBiosSupportedFunctions {
+                post_sound: true,
+                dedicated_gfx: true,
+                panel_overdrive: true,
+                dgpu_disable: true,
+                egpu_enable: true,
+            },
+        })
+    }
+}