Changes to keep compatibility with unsupported laptop models.

lenuswalker · lenuswalker · commit 1a1e7272ecd7 · 2024-05-01T16:38:13.000-04:00
diff --git a/LenovoLegionToolkit.Lib.Automation/AutomationProcessor.cs b/LenovoLegionToolkit.Lib.Automation/AutomationProcessor.cs
@@ -23,7 +23,7 @@ public class AutomationProcessor(
     GameAutoListener gameAutoListener,
     ProcessAutoListener processAutoListener,
     TimeAutoListener timeAutoListener,
-    TimeInveralAutoListener timeInveralAutoListener,
+    TimeIntervalAutoListener timeIntervalAutoListener,
     UserInactivityAutoListener userInactivityAutoListener,
     WiFiAutoListener wifiAutoListener)
 {
@@ -270,9 +270,9 @@ private async void TimeAutoListener_Changed(object? sender, TimeAutoListener.Cha
         await ProcessEvent(e).ConfigureAwait(false);
     }
 
-    private async void TimeIntervalAutoListener_Changed(object? sender, int interval)
+    private async void TimeIntervalAutoListener_Changed(object? sender, TimeIntervalAutoListener.ChangedEventArgs args)
     {
-        var e = new TimeIntervalAutomationEvent { Interval = interval };
+        var e = new TimeIntervalAutomationEvent(args.Interval);
         await ProcessEvent(e).ConfigureAwait(false);
     }
 
@@ -321,7 +321,7 @@ private async Task UpdateListenersAsync()
         await gameAutoListener.UnsubscribeChangedAsync(GameAutoListener_Changed).ConfigureAwait(false);
         await processAutoListener.UnsubscribeChangedAsync(ProcessAutoListener_Changed).ConfigureAwait(false);
         await timeAutoListener.UnsubscribeChangedAsync(TimeAutoListener_Changed).ConfigureAwait(false);
-        await timeInveralAutoListener.UnsubscribeChangedAsync(TimeIntervalAutoListener_Changed).ConfigureAwait(false);
+        await timeIntervalAutoListener.UnsubscribeChangedAsync(TimeIntervalAutoListener_Changed).ConfigureAwait(false);
         await userInactivityAutoListener.UnsubscribeChangedAsync(UserInactivityAutoListener_Changed).ConfigureAwait(false);
         await wifiAutoListener.UnsubscribeChangedAsync(WiFiAutoListener_Changed).ConfigureAwait(false);
 
diff --git a/LenovoLegionToolkit.Lib.Automation/Pipeline/Triggers/TimeIntervalAutomationPipelineTrigger.cs b/LenovoLegionToolkit.Lib.Automation/Pipeline/Triggers/TimeIntervalAutomationPipelineTrigger.cs
@@ -47,7 +47,7 @@ public async Task<bool> IsMatchingState()
         return false;
     }
 
-    public void UpdateEnvironment(ref AutomationEnvironment environment)
+    public void UpdateEnvironment(AutomationEnvironment environment)
     {
         environment.ACInterval = ACInterval;
         environment.DCInterval = DCInterval;
diff --git a/LenovoLegionToolkit.Lib.Automation/Steps/DisplayBrightnessAutomationStep.cs b/LenovoLegionToolkit.Lib.Automation/Steps/DisplayBrightnessAutomationStep.cs
@@ -19,5 +19,5 @@ public Task RunAsync(AutomationContext context, AutomationEnvironment environmen
         return _controller.SetBrightnessAsync(Brightness);
     }
 
-    public override IAutomationStep DeepCopy() => new DisplayBrightnessAutomationStep(State);
+    IAutomationStep IAutomationStep.DeepCopy() => new DisplayBrightnessAutomationStep(Brightness);
 }
diff --git a/LenovoLegionToolkit.Lib.Automation/Steps/ProcessAutomationStep.cs b/LenovoLegionToolkit.Lib.Automation/Steps/ProcessAutomationStep.cs
@@ -1,5 +1,6 @@
 ﻿using System;
 using System.Diagnostics;
+using System.Threading;
 using System.Threading.Tasks;
 using LenovoLegionToolkit.Lib.System;
 using Newtonsoft.Json;
@@ -17,7 +18,7 @@ public class ProcessAutomationStep : IAutomationStep
 
     public Task<bool> IsSupportedAsync() => Task.FromResult(true);
 
-    public async Task RunAsync(AutomationEnvironment _)
+    public async Task RunAsync(AutomationContext context, AutomationEnvironment environment, CancellationToken token)
     {
 
         if (State.Processes == null)
diff --git a/LenovoLegionToolkit.Lib.Automation/Steps/ProcessorTDPAutomationStep.cs b/LenovoLegionToolkit.Lib.Automation/Steps/ProcessorTDPAutomationStep.cs
@@ -1,4 +1,5 @@
 ﻿using System;
+using System.Threading;
 using System.Threading.Tasks;
 using LenovoLegionToolkit.Lib.Automation.Utils;
 using Newtonsoft.Json;
@@ -18,7 +19,7 @@ public class ProcessorTDPAutomationStep : IAutomationStep
 
     public Task<bool> IsSupportedAsync() => Task.FromResult(true);
 
-    public async Task RunAsync(AutomationEnvironment _)
+    public async Task RunAsync(AutomationContext context, AutomationEnvironment environment, CancellationToken token)
     {
         await _manager.InitializeAsync();
 
diff --git a/LenovoLegionToolkit.Lib.Automation/Utils/ProcessorManager.cs b/LenovoLegionToolkit.Lib.Automation/Utils/ProcessorManager.cs
@@ -12,7 +12,7 @@ namespace LenovoLegionToolkit.Lib.Automation.Utils;
 public class ProcessorManager
 {
     private readonly ProcessorController _controller = IoCContainer.Resolve<ProcessorController>();
-    private readonly TimeIntervalAutoListener _timeIntervalListener;
+    private readonly TimeIntervalAutoListener _timeIntervalAutoListener;
 
     private readonly AsyncLock _ioLock = new();
 
@@ -26,9 +26,9 @@ public class ProcessorManager
     private double _slow;
     private bool _useMSR;
 
-    public ProcessorManager(TimeIntervalAutoListener timeIntervalListener)
+    public ProcessorManager(TimeIntervalAutoListener timeIntervalAutoListener)
     {
-        _timeIntervalListener = timeIntervalListener ?? throw new ArgumentNullException(nameof(timeIntervalListener));
+        _timeIntervalAutoListener = timeIntervalAutoListener ?? throw new ArgumentNullException(nameof(timeIntervalAutoListener));
         // initialize processor
         _controller = _controller.GetCurrent();
     }
@@ -44,7 +44,7 @@ public async Task InitializeAsync()
         using (await _ioLock.LockAsync().ConfigureAwait(false))
         {
             //_timeIntervalListener.Changed += TimeIntervalListener_Changed;
-            await _timeIntervalListener.SubscribeChangedAsync(TimeIntervalListener_Changed).ConfigureAwait(false);
+            await _timeIntervalAutoListener.SubscribeChangedAsync(TimeIntervalAutoListener_Changed).ConfigureAwait(false);
 
             await StopAsync().ConfigureAwait(false);
         }
@@ -58,13 +58,24 @@ public Task StartAsync(double stapm, double fast, double slow, bool useMSR, int
         _useMSR = useMSR;
 
         if (Log.Instance.IsTraceEnabled)
-            Log.Instance.Trace($"Starting time interval listener...");
+            Log.Instance.Trace($"Setting processor TDP/power limits...");
 
-        _timeIntervalListener.StartAsync(interval*1000);
+        MaintainTDP(_stapm, _fast, _slow, _useMSR).ConfigureAwait(false);
 
         if (Log.Instance.IsTraceEnabled)
-            Log.Instance.Trace($"Stopped time interval listener...");
+            Log.Instance.Trace($"Processor TDP/power limits set");
 
+        if (interval > 0)
+        {
+            if (Log.Instance.IsTraceEnabled)
+                Log.Instance.Trace($"Starting time interval listener...");
+
+            _timeIntervalAutoListener.StartAsync(interval * 1000);
+
+            if (Log.Instance.IsTraceEnabled)
+                Log.Instance.Trace($"Started time interval listener.");
+        }
+        
         return Task.CompletedTask;
     }
 
@@ -73,10 +84,10 @@ public Task StopAsync()
         if (Log.Instance.IsTraceEnabled)
             Log.Instance.Trace($"Stopping time interval listener...");
 
-        _timeIntervalListener.StopNowAsync();
+        _timeIntervalAutoListener.StopNowAsync();
 
         if (Log.Instance.IsTraceEnabled)
-            Log.Instance.Trace($"Stopped time interval listener...");
+            Log.Instance.Trace($"Stopped time interval listener.");
 
         _stapm = 0;
         _fast = 0;
@@ -177,7 +188,7 @@ public Task MaintainTDP(double stapm, double fast, double slow, bool useMSR)
         return Task.CompletedTask;
     }
 
-    private async void TimeIntervalListener_Changed(object? sender, int interval)
+    private async void TimeIntervalAutoListener_Changed(object? sender, TimeIntervalAutoListener.ChangedEventArgs e)
     {
         await MaintainTDP(_stapm, _fast, _slow, _useMSR).ConfigureAwait(false);
     }
diff --git a/LenovoLegionToolkit.Lib/AutoListeners/TimeIntervalAutoListener.cs b/LenovoLegionToolkit.Lib/AutoListeners/TimeIntervalAutoListener.cs
@@ -5,8 +5,13 @@
 
 namespace LenovoLegionToolkit.Lib.AutoListeners;
 
-public class TimeIntervalAutoListener : AbstractAutoListener<int>
+public class TimeIntervalAutoListener : AbstractAutoListener<TimeIntervalAutoListener.ChangedEventArgs>
 {
+    public class ChangedEventArgs(int interval) : EventArgs
+    {
+        public int Interval { get; } = interval;
+    }
+
     private readonly Timer _timer;
     
     public TimeIntervalAutoListener()
@@ -60,5 +65,5 @@ public Task StopNowAsync()
         return Task.CompletedTask;
     }
 
-    private void Timer_Elapsed(object? sender, ElapsedEventArgs e) => RaiseChanged((int)_timer.Interval);
+    private void Timer_Elapsed(object? sender, ElapsedEventArgs e) => RaiseChanged(new ChangedEventArgs((int)_timer.Interval));
 }
diff --git a/LenovoLegionToolkit.Lib/Controllers/DisplayBrightnessController.cs b/LenovoLegionToolkit.Lib/Controllers/DisplayBrightnessController.cs
@@ -0,0 +1,9 @@
+﻿using System.Threading.Tasks;
+using LenovoLegionToolkit.Lib.System.Management;
+
+namespace LenovoLegionToolkit.Lib.Controllers;
+
+public class DisplayBrightnessController
+{
+    public Task SetBrightnessAsync(int brightness) => WMI.WmiMonitorBrightnessMethods.WmiSetBrightness(brightness, 1);
+}
diff --git a/LenovoLegionToolkit.Lib/Controllers/PowerPlanController.cs b/LenovoLegionToolkit.Lib/Controllers/PowerPlanController.cs
@@ -1,6 +1,7 @@
 ﻿using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Runtime;
 using System.Runtime.InteropServices;
 using System.Threading.Tasks;
 using LenovoLegionToolkit.Lib.Extensions;
@@ -59,7 +60,11 @@ public async Task SetPowerPlanAsync(PowerModeState powerModeState, bool alwaysAc
             if (Log.Instance.IsTraceEnabled)
                 Log.Instance.Trace($"Power plan for power mode {powerModeState} was not found in settings");
 
-            powerPlanId = DefaultPowerPlan;
+            if (DefaultPowerModes.TryGetValue(powerModeState, out var defaultPowerPlanId))
+                powerPlanId = defaultPowerPlanId;
+            else
+                throw new InvalidOperationException("Unknown state");
+
             isDefault = true;
         }
 
@@ -104,6 +109,20 @@ public async Task SetPowerPlanAsync(PowerModeState powerModeState, bool alwaysAc
             Log.Instance.Trace($"Power plan {powerPlanToActivate.Guid} activated. [name={powerPlanToActivate.Name}]");
     }
 
+    public PowerModeState[] GetMatchingPowerModes(Guid powerPlanGuid)
+    {
+        var powerModes = new Dictionary<PowerModeState, Guid>(DefaultPowerModes);
+
+        foreach (var kv in settings.Store.PowerPlans)
+        {
+            powerModes[kv.Key] = kv.Value;
+        }
+
+        return powerModes.Where(kv => kv.Value == powerPlanGuid)
+            .Select(kv => kv.Key)
+            .ToArray();
+    }
+
     public void SetPowerPlanParameter(PowerPlan powerPlan, Brightness brightness)
     {
         PInvoke.PowerWriteACValueIndex(NullSafeHandle.Null, powerPlan.Guid, PInvoke.GUID_VIDEO_SUBGROUP, PInvokeExtensions.DISPLAY_BRIGTHNESS_SETTING_GUID, brightness.Value);
diff --git a/LenovoLegionToolkit.Lib/Features/AbstractWmiFeature.cs b/LenovoLegionToolkit.Lib/Features/AbstractWmiFeature.cs
@@ -4,36 +4,44 @@
 
 namespace LenovoLegionToolkit.Lib.Features;
 
-public abstract class AbstractWmiFeature<T>(
-    Func<Task<int>> getValue,
-    Func<int, Task> setValue,
-    Func<Task<int>>? isSupported = null,
-    int offset = 0)
-    : IFeature<T>
-    where T : struct, Enum, IComparable
+public abstract class AbstractWmiFeature<T> : IFeature<T> where T : struct, Enum, IComparable
 {
-    public async Task<bool> IsSupportedAsync()
+    private readonly Func<Task<int>> _getValue;
+    private readonly Func<int, Task> _setValue;
+    public readonly Func<Task<int>>? _isSupported;
+    private readonly int _offset;
+
+    protected AbstractWmiFeature(Func<Task<int>> getValue, Func<int, Task> setValue, Func<Task<int>>? isSupported = null, int offset = 0)
+    {
+        _getValue = getValue;
+        _setValue = setValue;
+        _isSupported = isSupported;
+        _offset = offset;
+    }
+
+    public virtual async Task<bool> IsSupportedAsync()
     {
         try
         {
-            if (isSupported is null)
+            if (_isSupported is null)
                 return true;
 
-            return await isSupported().ConfigureAwait(false) > 0;
+            return await _isSupported().ConfigureAwait(false) > 0;
         }
         catch
         {
             return false;
         }
     }
+
     public virtual Task<T[]> GetAllStatesAsync() => Task.FromResult(Enum.GetValues<T>());
 
     public virtual async Task<T> GetStateAsync()
     {
         if (Log.Instance.IsTraceEnabled)
             Log.Instance.Trace($"Getting state... [feature={GetType().Name}]");
 
-        var internalResult = await getValue().ConfigureAwait(false);
+        var internalResult = await _getValue().ConfigureAwait(false);
         var result = FromInternal(internalResult);
 
         if (Log.Instance.IsTraceEnabled)
@@ -48,13 +56,13 @@ public virtual async Task SetStateAsync(T state)
         if (Log.Instance.IsTraceEnabled)
             Log.Instance.Trace($"Setting state to {state}... [feature={GetType().Name}]");
 
-        await setValue(ToInternal(state)).ConfigureAwait(false);
+        await _setValue(ToInternal(state)).ConfigureAwait(false);
 
         if (Log.Instance.IsTraceEnabled)
             Log.Instance.Trace($"Set state to {state} [feature={GetType().Name}]");
     }
 
-    private int ToInternal(T state) => (int)(object)state + offset;
+    private int ToInternal(T state) => (int)(object)state + _offset;
 
-    private T FromInternal(int state) => (T)(object)(state - offset);
+    private T FromInternal(int state) => (T)(object)(state - _offset);
 }
diff --git a/LenovoLegionToolkit.Lib/Features/PowerModeFeature.cs b/LenovoLegionToolkit.Lib/Features/PowerModeFeature.cs
@@ -46,7 +46,7 @@ public override async Task<bool> IsSupportedAsync()
             uint result = Power.PowerGetEffectiveOverlayScheme(out Guid currentMode);
             if (result == 0)
                 return true;
-            else                
+            else
                 return false;
         }
     }
@@ -108,12 +108,12 @@ public override async Task SetStateAsync(PowerModeState state)
                 throw new PowerModeUnavailableWithoutACException(state);
 
 
-        if (mi.Properties.HasQuietToPerformanceModeSwitchingBug && currentState == PowerModeState.Quiet && state == PowerModeState.Performance)
-        {
-            thermalModeListener.SuppressNext();
-            await base.SetStateAsync(PowerModeState.Balance).ConfigureAwait(false);
-            await Task.Delay(TimeSpan.FromMilliseconds(500)).ConfigureAwait(false);
-        }
+            if (mi.Properties.HasQuietToPerformanceModeSwitchingBug && currentState == PowerModeState.Quiet && state == PowerModeState.Performance)
+            {
+                thermalModeListener.SuppressNext();
+                await base.SetStateAsync(PowerModeState.Balance).ConfigureAwait(false);
+                await Task.Delay(TimeSpan.FromMilliseconds(500)).ConfigureAwait(false);
+            }
 
             if (mi.Properties.HasGodModeToOtherModeSwitchingBug && currentState == PowerModeState.GodMode && state != PowerModeState.GodMode)
             {
diff --git a/LenovoLegionToolkit.Lib/IoCModule.cs b/LenovoLegionToolkit.Lib/IoCModule.cs
@@ -87,6 +87,7 @@ protected override void Load(ContainerBuilder builder)
         builder.Register<LightingChangeListener>().AutoActivateListener();
         builder.Register<NativeWindowsMessageListener>().AutoActivateListener();
         builder.Register<PowerModeListener>().AutoActivateListener();
+        builder.Register<PowerPlanListener>().AutoActivateListener();
         builder.Register<PowerStateListener>().AutoActivateListener();
         builder.Register<RGBKeyboardBacklightListener>().AutoActivateListener();
         builder.Register<SpecialKeyListener>().AutoActivateListener();
@@ -104,6 +105,7 @@ protected override void Load(ContainerBuilder builder)
         builder.Register<WiFiAutoListener>();
 
         builder.Register<AIController>();
+        builder.Register<DisplayBrightnessController>();
         builder.Register<GodModeController>();
         builder.Register<GodModeControllerV1>(true);
         builder.Register<GodModeControllerV2>(true);
diff --git a/LenovoLegionToolkit.Lib/Listeners/PowerPlanListener.cs b/LenovoLegionToolkit.Lib/Listeners/PowerPlanListener.cs
@@ -42,15 +42,14 @@ protected override async Task OnChangedAsync()
             }
 
         var vantageStatus = await _vantageDisabler.GetStatusAsync().ConfigureAwait(false);
-        var activateWhenVantageEnabled = _settings.Store.ActivatePowerProfilesWithVantageEnabled;
-        if (vantageStatus == SoftwareStatus.Enabled && !activateWhenVantageEnabled)
+        if (vantageStatus == SoftwareStatus.Enabled)
         {
             if (Log.Instance.IsTraceEnabled)
-                Log.Instance.Trace($"Ignoring. [vantage.status={vantageStatus}, activateWhenVantageEnabled={activateWhenVantageEnabled}]");
+                Log.Instance.Trace($"Ignoring. [vantage.status={vantageStatus}]");
             return;
         }
 
-        var powerPlans = _powerPlanController.GetPowerPlans().ToArray();
+        var powerPlans = _powerPlanController.GetPowerPlans(true, false).ToArray();
         var activePowerPlan = powerPlans.First(pp => pp.IsActive);
 
         var powerModes = _powerPlanController.GetMatchingPowerModes(activePowerPlan.Guid);
diff --git a/LenovoLegionToolkit.WPF/Controls/Automation/Steps/DisplayBrightnessAutomationStepControl.cs b/LenovoLegionToolkit.WPF/Controls/Automation/Steps/DisplayBrightnessAutomationStepControl.cs
@@ -45,7 +45,7 @@ protected override UIElement GetCustomControl()
     {
         _brightness.ValueChanged += (_, _) =>
         {
-            if (_brightness.Value != AutomationStep.State)
+            if (_brightness.Value != AutomationStep.Brightness)
                 RaiseChanged();
         };
 
@@ -58,7 +58,7 @@ protected override void OnFinishedLoading() { }
 
     protected override Task RefreshAsync()
     {
-        _brightness.Value = AutomationStep.State;
+        _brightness.Value = AutomationStep.Brightness;
         return Task.CompletedTask;
     }
 }
diff --git a/LenovoLegionToolkit.WPF/Controls/Dashboard/PowerModeControl.cs b/LenovoLegionToolkit.WPF/Controls/Dashboard/PowerModeControl.cs
diff --git a/LenovoLegionToolkit.WPF/Extensions/DashboardItemExtensions.cs b/LenovoLegionToolkit.WPF/Extensions/DashboardItemExtensions.cs
diff --git a/LenovoLegionToolkit.WPF/Resources/AMD/libryzenadj.dll b/LenovoLegionToolkit.WPF/Resources/AMD/libryzenadj.dll
diff --git a/LenovoLegionToolkit.WPF/Resources/AMD/ryzenadj.exe b/LenovoLegionToolkit.WPF/Resources/AMD/ryzenadj.exe
diff --git a/LenovoLegionToolkit.WPF/Windows/Utils/StatusWindow.xaml.cs b/LenovoLegionToolkit.WPF/Windows/Utils/StatusWindow.xaml.cs
diff --git a/LenovoLegionToolkit.WPF/libryzenadj.dll b/LenovoLegionToolkit.WPF/libryzenadj.dll

Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,7 @@ public async Task<bool> IsMatchingState()`
`47`	`47`	`return false;`
`48`	`48`	`}`
`49`	`49`
`50`		`- public void UpdateEnvironment(ref AutomationEnvironment environment)`
	`50`	`+ public void UpdateEnvironment(AutomationEnvironment environment)`
`51`	`51`	`{`
`52`	`52`	`environment.ACInterval = ACInterval;`
`53`	`53`	`environment.DCInterval = DCInterval;`
Original file line number	Diff line number	Diff line change
`@@ -19,5 +19,5 @@ public Task RunAsync(AutomationContext context, AutomationEnvironment environmen`
`19`	`19`	`return _controller.SetBrightnessAsync(Brightness);`
`20`	`20`	`}`
`21`	`21`
`22`		`- public override IAutomationStep DeepCopy() => new DisplayBrightnessAutomationStep(State);`
	`22`	`+ IAutomationStep IAutomationStep.DeepCopy() => new DisplayBrightnessAutomationStep(Brightness);`
`23`	`23`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,8 +5,13 @@`
`5`	`5`
`6`	`6`	`namespace LenovoLegionToolkit.Lib.AutoListeners;`
`7`	`7`
`8`		`-public class TimeIntervalAutoListener : AbstractAutoListener<int>`
	`8`	`+public class TimeIntervalAutoListener : AbstractAutoListener<TimeIntervalAutoListener.ChangedEventArgs>`
`9`	`9`	`{`
	`10`	`+ public class ChangedEventArgs(int interval) : EventArgs`
	`11`	`+ {`
	`12`	`+ public int Interval { get; } = interval;`
	`13`	`+ }`
	`14`	`+`
`10`	`15`	`private readonly Timer _timer;`
`11`	`16`
`12`	`17`	`public TimeIntervalAutoListener()`
`@@ -60,5 +65,5 @@ public Task StopNowAsync()`
`60`	`65`	`return Task.CompletedTask;`
`61`	`66`	`}`
`62`	`67`
`63`		`- private void Timer_Elapsed(object? sender, ElapsedEventArgs e) => RaiseChanged((int)_timer.Interval);`
	`68`	`+ private void Timer_Elapsed(object? sender, ElapsedEventArgs e) => RaiseChanged(new ChangedEventArgs((int)_timer.Interval));`
`64`	`69`	`}`