LenovoLegionToolkit

1
using System;
2
using System.Threading.Tasks;
3
using LenovoLegionToolkit.Lib.Extensions;
4
using LenovoLegionToolkit.Lib.System;
5

6
namespace LenovoLegionToolkit.Lib.Features;
7

8
public class BatteryFeature : AbstractDriverFeature<BatteryState>
9
{
10
    private const string BATTERY_CHARGE_MODE_HIVE = "HKEY_CURRENT_USER";
11
    private const string BATTERY_CHARGE_MODE_PATH = "Software\\Lenovo\\VantageService\\AddinData\\IdeaNotebookAddin";
12
    private const string BATTERY_CHARGE_MODE_KEY = "BatteryChargeMode";
13
    private const string BATTERY_CHARGE_MODE_NORMAL = "Normal";
14
    private const string BATTERY_CHARGE_MODE_RAPID_CHARGE = "Quick";
15
    private const string BATTERY_CHARGE_MODE_CONSERVATION = "Storage";
16

17
    public BatteryFeature() : base(Drivers.GetEnergy, Drivers.IOCTL_ENERGY_BATTERY_CHARGE_MODE) { }
18

19
    protected override uint GetInBufferValue() => 0xFF;
20

21
    protected override Task<uint[]> ToInternalAsync(BatteryState state)
22
    {
23
        var result = state switch
24
        {
25
            BatteryState.Conservation => LastState == BatteryState.RapidCharge ? new uint[] { 0x8, 0x3 } : new uint[] { 0x3 },
26
            BatteryState.Normal => LastState == BatteryState.Conservation ? new uint[] { 0x5 } : new uint[] { 0x8 },
27
            BatteryState.RapidCharge => LastState == BatteryState.Conservation ? new uint[] { 0x5, 0x7 } : new uint[] { 0x7 },
28
            _ => throw new InvalidOperationException("Invalid state.")
29
        };
30
        return Task.FromResult(result);
31
    }
32

33
    protected override Task<BatteryState> FromInternalAsync(uint state)
34
    {
35
        state = state.ReverseEndianness();
36

37
        if (state.GetNthBit(17)) // Is charging?
38
            return Task.FromResult(state.GetNthBit(26) ? BatteryState.RapidCharge : BatteryState.Normal);
39

40
        if (state.GetNthBit(29))
41
            return Task.FromResult(BatteryState.Conservation);
42

43
        throw new InvalidOperationException($"Unknown battery state: {state} [bits={Convert.ToString(state, 2)}]");
44
    }
45

46
    public override async Task SetStateAsync(BatteryState state)
47
    {
48
        await base.SetStateAsync(state).ConfigureAwait(false);
49
        SetStateInRegistry(state);
50
    }
51

52
    public async Task EnsureCorrectBatteryModeIsSetAsync()
53
    {
54
        var state = GetStateFromRegistry();
55

56
        if (!state.HasValue)
57
            return;
58

59
        if (await GetStateAsync().ConfigureAwait(false) == state.Value)
60
            return;
61

62
        await SetStateAsync(state.Value).ConfigureAwait(false);
63
    }
64

65
    private static BatteryState? GetStateFromRegistry()
66
    {
67
        var batteryModeString = Registry.GetValue(BATTERY_CHARGE_MODE_HIVE, BATTERY_CHARGE_MODE_PATH, BATTERY_CHARGE_MODE_KEY, string.Empty);
68
        return batteryModeString switch
69
        {
70
            BATTERY_CHARGE_MODE_NORMAL => BatteryState.Normal,
71
            BATTERY_CHARGE_MODE_RAPID_CHARGE => BatteryState.RapidCharge,
72
            BATTERY_CHARGE_MODE_CONSERVATION => BatteryState.Conservation,
73
            _ => null
74
        };
75
    }
76

77
    private static void SetStateInRegistry(BatteryState state)
78
    {
79
        var batteryModeString = state switch
80
        {
81
            BatteryState.Normal => BATTERY_CHARGE_MODE_NORMAL,
82
            BatteryState.RapidCharge => BATTERY_CHARGE_MODE_RAPID_CHARGE,
83
            BatteryState.Conservation => BATTERY_CHARGE_MODE_CONSERVATION,
84
            _ => null
85
        };
86

87
        if (batteryModeString is null)
88
            return;
89

90
        Registry.SetValue(BATTERY_CHARGE_MODE_HIVE, BATTERY_CHARGE_MODE_PATH, BATTERY_CHARGE_MODE_KEY, batteryModeString);
91
    }
92
}
93