LenovoLegionToolkit

1
using System;
2
using System.Linq;
3
using System.Threading.Tasks;
4
using LenovoLegionToolkit.Lib.Controllers;
5
using LenovoLegionToolkit.Lib.Controllers.GodMode;
6
using LenovoLegionToolkit.Lib.Listeners;
7
using LenovoLegionToolkit.Lib.System;
8
using LenovoLegionToolkit.Lib.System.Management;
9
using LenovoLegionToolkit.Lib.Utils;
10

11
namespace LenovoLegionToolkit.Lib.Features;
12

13
public class PowerModeUnavailableWithoutACException : Exception
14
{
15
    public PowerModeState PowerMode { get; }
16

17
    public PowerModeUnavailableWithoutACException(PowerModeState powerMode)
18
    {
19
        PowerMode = powerMode;
20
    }
21
}
22

23
public class PowerModeFeature : AbstractWmiFeature<PowerModeState>
24
{
25
    private readonly GodModeController _godModeController;
26
    private readonly PowerPlanController _powerPlanController;
27
    private readonly ThermalModeListener _thermalModeListener;
28
    private readonly PowerModeListener _powerModeListener;
29

30
    public bool AllowAllPowerModesOnBattery { get; set; }
31

32
    public PowerModeFeature(GodModeController godModeController, PowerPlanController powerPlanController, ThermalModeListener thermalModeListener, PowerModeListener powerModeListener)
33
        : base(WMI.LenovoGameZoneData.GetSmartFanModeAsync, WMI.LenovoGameZoneData.SetSmartFanModeAsync, WMI.LenovoGameZoneData.IsSupportSmartFanAsync, 1)
34
    {
35
        _godModeController = godModeController ?? throw new ArgumentNullException(nameof(godModeController));
36
        _powerPlanController = powerPlanController ?? throw new ArgumentNullException(nameof(powerPlanController));
37
        _thermalModeListener = thermalModeListener ?? throw new ArgumentNullException(nameof(thermalModeListener));
38
        _powerModeListener = powerModeListener ?? throw new ArgumentNullException(nameof(powerModeListener));
39
    }
40

41
    public override async Task<PowerModeState[]> GetAllStatesAsync()
42
    {
43
        var mi = await Compatibility.GetMachineInformationAsync().ConfigureAwait(false);
44
        return mi.Properties.SupportsGodMode
45
            ? new[] { PowerModeState.Quiet, PowerModeState.Balance, PowerModeState.Performance, PowerModeState.GodMode }
46
            : new[] { PowerModeState.Quiet, PowerModeState.Balance, PowerModeState.Performance };
47
    }
48

49
    public override async Task SetStateAsync(PowerModeState state)
50
    {
51
        var allStates = await GetAllStatesAsync().ConfigureAwait(false);
52
        if (!allStates.Contains(state))
53
            throw new InvalidOperationException($"Unsupported power mode {state}.");
54

55
        if (state is PowerModeState.Performance or PowerModeState.GodMode
56
            && !AllowAllPowerModesOnBattery
57
            && await Power.IsPowerAdapterConnectedAsync().ConfigureAwait(false) is PowerAdapterStatus.Disconnected)
58
            throw new PowerModeUnavailableWithoutACException(state);
59

60
        var currentState = await GetStateAsync().ConfigureAwait(false);
61

62
        var mi = await Compatibility.GetMachineInformationAsync().ConfigureAwait(false);
63

64
        if (mi.Properties.HasQuietToPerformanceModeSwitchingBug && currentState == PowerModeState.Quiet && state == PowerModeState.Performance)
65
        {
66
            _thermalModeListener.SuppressNext();
67
            await base.SetStateAsync(PowerModeState.Balance).ConfigureAwait(false);
68
            await Task.Delay(TimeSpan.FromMilliseconds(500)).ConfigureAwait(false);
69
        }
70

71
        if (mi.Properties.HasGodModeToOtherModeSwitchingBug && currentState == PowerModeState.GodMode && state != PowerModeState.GodMode)
72
        {
73
            _thermalModeListener.SuppressNext();
74

75
            switch (state)
76
            {
77
                case PowerModeState.Quiet:
78
                    await base.SetStateAsync(PowerModeState.Performance).ConfigureAwait(false);
79
                    break;
80
                case PowerModeState.Balance:
81
                    await base.SetStateAsync(PowerModeState.Quiet).ConfigureAwait(false);
82
                    break;
83
                case PowerModeState.Performance:
84
                    await base.SetStateAsync(PowerModeState.Balance).ConfigureAwait(false);
85
                    break;
86
            }
87

88
            await Task.Delay(TimeSpan.FromMilliseconds(500)).ConfigureAwait(false);
89

90
        }
91

92
        _thermalModeListener.SuppressNext();
93
        await base.SetStateAsync(state).ConfigureAwait(false);
94

95
        if (state == PowerModeState.GodMode)
96
            await _godModeController.ApplyStateAsync().ConfigureAwait(false);
97

98
        await _powerModeListener.NotifyAsync(state).ConfigureAwait(false);
99
    }
100

101
    public async Task EnsureCorrectPowerPlanIsSetAsync()
102
    {
103
        var state = await GetStateAsync().ConfigureAwait(false);
104
        await _powerPlanController.ActivatePowerPlanAsync(state, true).ConfigureAwait(false);
105
    }
106

107
    public async Task EnsureGodModeStateIsAppliedAsync()
108
    {
109
        var state = await GetStateAsync().ConfigureAwait(false);
110
        if (state != PowerModeState.GodMode)
111
            return;
112

113
        await _godModeController.ApplyStateAsync().ConfigureAwait(false);
114
    }
115
}
116