/// <summary>
/// Set the specified preference to the given value
/// </summary>
/// <remarks>
/// Calls <code>SetNeedsPreferencesSave()</code> to queue a save after a timeout.
/// </remarks>
/// <param name="key">The preference lookup key</param>
/// <param name="value">The preference value</param>
/// <returns>Whether the preference was successfully applied to the system</returns>
public bool SetPreference(Preferences.Key key, object?value)
{
logger.LogInformation("Setting {0}={1}", key, value);
Preferences?.Set(key, value);
SetNeedsPreferencesSave();
return(true);
}
public void TestCopyConstructor()
{
var preferences = new Preferences();
var key1 = new Preferences.Key("org.raisingthefloor.test", "one");
var key2 = new Preferences.Key("org.raisingthefloor.test", "two");
var key3 = new Preferences.Key("org.raisingthefloor.test", "three");
preferences.Set(key1, "Hello");
preferences.Set(key2, 12L);
preferences.Set(key3, new Dictionary <string, string>()
{
{ "a", "value1" },
{ "b", "value2" }
});
var preferences2 = new Preferences(preferences);
var value = preferences2.Get(key1);
Assert.IsType <string>(value);
Assert.Equal("Hello", (string)value);
value = preferences2.Get(key2);
Assert.IsType <long>(value);
Assert.Equal(12, (long)value);
value = preferences2.Get(key3);
Assert.IsType <Dictionary <string, string> >(value);
Assert.Equal("value1", ((Dictionary <string, string>)value)["a"]);
Assert.Equal("value2", ((Dictionary <string, string>)value)["b"]);
preferences.Set(key1, "World");
value = preferences2.Get(key1);
Assert.IsType <string>(value);
Assert.Equal("Hello", (string)value);
preferences2.Set(key1, "Testing");
value = preferences.Get(key1);
Assert.IsType <string>(value);
Assert.Equal("World", (string)value);
preferences.Set(key3, new Dictionary <string, string>()
{
{ "a", "changed1" }
});
value = preferences2.Get(key3);
Assert.IsType <Dictionary <string, string> >(value);
Assert.Equal("value1", ((Dictionary <string, string>)value)["a"]);
Assert.Equal("value2", ((Dictionary <string, string>)value)["b"]);
preferences2.Set(key3, new Dictionary <string, string>()
{
{ "a", "changed2" }
});
value = preferences.Get(key3);
Assert.IsType <Dictionary <string, string> >(value);
Assert.Equal("changed1", ((Dictionary <string, string>)value)["a"]);
}
public async Task <object?> Capture(Preferences.Key key)
{
var prefs = new Preferences();
var session = new CaptureSession(this, prefs);
session.CaptureDefaultValues = true;
session.Keys.Add(key);
await session.Run();
return(prefs.Get(key));
}
public ManualControlBoolean(MainWindow window, SettingsManager manager, string solutionId, Setting setting)
{
InitializeComponent();
this.window = window;
this.manager = manager;
this.solutionId = solutionId;
this.setting = setting;
key = new Preferences.Key(solutionId, setting.Name);
ControlName.Text = setting.Name;
CheckValue();
}
/// <summary>
/// Get the setting for the given preference key
/// </summary>
/// <param name="key">The key of the setting to lookup</param>
/// <returns></returns>
public Setting?Get(Preferences.Key key)
{
if (SolutionsById.TryGetValue(key.Solution, out var solution))
{
if (solution.SettingsByName.TryGetValue(key.Preference, out var setting))
{
return(setting);
}
}
return(null);
}
/// <summary>
/// Apply the given value for the given prefernce
/// </summary>
/// <remarks>
/// Looks for a settings handler for the given key
/// </remarks>
/// <param name="key">The preference key</param>
/// <param name="value">The value to apply</param>
/// <returns></returns>
public async Task <bool> Apply(Preferences.Key key, object?value)
{
var results = await Apply(new Dictionary <Preferences.Key, object?>
{
{ key, value }
});
if (results.TryGetValue(key, out var result))
{
return(result);
}
return(false);
}
void TestRemove()
{
var preferences = new Preferences();
var key1 = new Preferences.Key("org.raisingthefloor.test", "one");
var key2 = new Preferences.Key("org.raisingthefloor.test", "two");
var key3 = new Preferences.Key("org.raisingthefloor.test2", "three");
preferences.Set(key1, "Hello");
preferences.Set(key2, 12L);
preferences.Set(key3, new Dictionary <string, string>()
{
{ "a", "value1" },
{ "b", "value2" }
});
Assert.True(preferences.Default.TryGetValue("org.raisingthefloor.test", out var solutionPreferences));
Assert.True(solutionPreferences.Values.ContainsKey("one"));
Assert.True(solutionPreferences.Values.ContainsKey("two"));
Assert.True(preferences.Default.TryGetValue("org.raisingthefloor.test2", out solutionPreferences));
Assert.True(solutionPreferences.Values.ContainsKey("three"));
preferences.Remove(key1);
Assert.True(preferences.Default.TryGetValue("org.raisingthefloor.test", out solutionPreferences));
Assert.False(solutionPreferences.Values.ContainsKey("one"));
Assert.True(solutionPreferences.Values.ContainsKey("two"));
Assert.True(preferences.Default.TryGetValue("org.raisingthefloor.test2", out solutionPreferences));
Assert.True(solutionPreferences.Values.ContainsKey("three"));
preferences.Remove(key3);
Assert.True(preferences.Default.TryGetValue("org.raisingthefloor.test", out solutionPreferences));
Assert.False(solutionPreferences.Values.ContainsKey("one"));
Assert.True(solutionPreferences.Values.ContainsKey("two"));
Assert.False(preferences.Default.TryGetValue("org.raisingthefloor.test2", out solutionPreferences));
preferences.Remove(key2);
Assert.False(preferences.Default.TryGetValue("org.raisingthefloor.test", out solutionPreferences));
Assert.False(preferences.Default.TryGetValue("org.raisingthefloor.test2", out solutionPreferences));
}
/// <summary>
/// Get an array preference
/// </summary>
/// <param name="key">The preference key</param>
/// <returns>The requested array or <code>null</code> if no array is found for the key</returns>
public object?[]? GetArray(Preferences.Key key)
{
return(Preferences?.Get(key) as object?[]);
}
/// <summary>
/// Get a dictionary preference
/// </summary>
/// <param name="key">The preference key</param>
/// <returns>The requested dictionary or <code>null</code> if no dictionary is found for the key</returns>
public Dictionary <string, object?>?GetDictionary(Preferences.Key key)
{
return(Preferences?.Get(key) as Dictionary <string, object?>);
}
/// <summary>
/// Get a boolean preference
/// </summary>
/// <param name="key">The preference key</param>
/// <returns>The requested boolean or <code>null</code> if no boolea is found for the key</returns>
public bool?GetBool(Preferences.Key key)
{
return(Preferences?.Get(key) as bool?);
}
/// <summary>
/// Get an integer preference
/// </summary>
/// <param name="key">The preference key</param>
/// <returns>The requested integer or <code>null</code> if no integer is found for the key</returns>
public long?GetInteger(Preferences.Key key)
{
return(Preferences?.Get(key) as long?);
}
/// <summary>
/// Get a double preference
/// </summary>
/// <param name="key">The preference key</param>
/// <returns>The requested double or <code>null</code> if no double is found for the key</returns>
public double?GetDouble(Preferences.Key key)
{
return(Preferences?.Get(key) as double?);
}
/// <summary>
/// Get a string preference
/// </summary>
/// <param name="key">The preference key</param>
/// <returns>The requested string or <code>null</code> if no string is found for the key</returns>
public string?GetString(Preferences.Key key)
{
return(Preferences?.Get(key) as string);
}
/// <summary>
/// Set the specified preference to the given value
/// </summary>
/// <remarks>
/// Calls <code>SetNeedsPreferencesSave()</code> to queue a save after a timeout.
/// </remarks>
/// <param name="key">The preference lookup key</param>
/// <param name="value">The preference value</param>
/// <returns>Whether the preference was successfully applied to the system</returns>
public async Task <bool> Apply(Preferences.Key key, object?value)
{
return(await SettingsManager.Apply(key, value));
}
/// <summary>
/// Add a client setting handler for the given key
/// </summary>
/// <param name="type"></param>
/// <param name="key"></param>
public void AddClientHandler(Type type, Preferences.Key key)
{
services.AddTransient(type);
SettingHandler.RegisterClientHandler(type, key);
}
/// <summary>
/// Apply all the settings
/// </summary>
/// <returns></returns>
public async Task <Dictionary <Preferences.Key, bool> > Run()
{
var valuesByKey = ValuesByKey;
if (ApplyDefaultValues)
{
// Loop through all settings and add the default value for any setting
// that isn't already in valuesByKey
valuesByKey = new Dictionary <Preferences.Key, object?>(valuesByKey);
foreach (var solution in SettingsManager.SolutionsById.Values)
{
foreach (var setting in solution.Settings)
{
if (setting.Default is object defaultValue)
{
var key = new Preferences.Key(solution.Id, setting.Name);
if (!valuesByKey.ContainsKey(key))
{
valuesByKey.Add(key, defaultValue);
}
}
else
{
SettingsManager.logger.LogWarning("null default value, skipping");
}
}
}
}
var resultsByKey = new Dictionary <Preferences.Key, bool>();
var uniqueFinalizerDescriptions = new HashSet <SettingFinalizerDescription>();
var serviceProvider = SettingsManager;
var logger = serviceProvider.GetService <ILogger <ApplySession> >();
var iniFactory = serviceProvider.GetRequiredService <IIniFileFactory>();
await iniFactory.Begin();
// Keep track of any unique finalizers that need to run
// TODO: enforce any order dependency among settings (currently no known dependencies, but
// some are expected)
foreach (var pair in valuesByKey)
{
if (SettingsManager.Get(pair.Key) is Setting setting)
{
if (setting.CreateHandler(serviceProvider) is SettingHandler handler)
{
logger.LogInformation("Applying {0}.{1}", pair.Key.Solution, pair.Key.Preference);
var success = await handler.Apply(pair.Value);
if (success)
{
if (setting.FinalizerDescription is SettingFinalizerDescription finalizerDescription)
{
uniqueFinalizerDescriptions.Add(finalizerDescription);
}
}
else
{
logger.LogError("Failed to set {0}.{1}", pair.Key.Solution, pair.Key.Preference);
}
resultsByKey.Add(pair.Key, success);
}
else
{
logger.LogError("No handler for {0}.{1}", pair.Key.Solution, pair.Key.Preference);
resultsByKey.Add(pair.Key, false);
}
}
else
{
logger.LogError("No definition found for {0}.{1}", pair.Key.Solution, pair.Key.Preference);
resultsByKey.Add(pair.Key, false);
}
}
await iniFactory.Commit();
if (uniqueFinalizerDescriptions.Count > 0)
{
logger.LogInformation("Running finalizers");
// Run the unique finalizers
foreach (var finalizerDescription in uniqueFinalizerDescriptions)
{
if (finalizerDescription.CreateFinalizer(serviceProvider) is SettingFinalizer finalizer)
{
var success = await finalizer.Run();
if (!success)
{
logger.LogError("Finalizer failed");
}
}
}
logger.LogInformation("Finalizers done");
}
return(resultsByKey);
}
public ClientSettingHandlerDescription(Preferences.Key key) : base(HandlerKind.Client)
{
Key = key;
}
public override SettingHandlerDescription Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
{
try
{
var document = JsonDocument.ParseValue(ref reader);
var element = document.RootElement;
var type = element.GetProperty("type").GetString();
switch (type)
{
case "org.raisingthefloor.morphic.client":
{
var solution = element.GetProperty("solution").GetString();
var preference = element.GetProperty("preference").GetString();
var key = new Preferences.Key(solution, preference);
return(new ClientSettingHandlerDescription(key));
}
case "com.microsoft.windows.registry":
{
var keyName = element.GetProperty("key_name").GetString();
var valueName = element.GetProperty("value_name").GetString();
var valueType = element.GetProperty("value_type").GetString();
var valueKind = Enum.Parse <RegistryValueKind>(valueType, ignoreCase: true);
return(new RegistrySettingHandlerDescription(keyName, valueName, valueKind));
}
case "com.microsoft.windows.ini":
{
var filename = element.GetProperty("filename").GetString();
var section = element.GetProperty("section").GetString();
var key = element.GetProperty("key").GetString();
return(new IniSettingHandlerDescription(filename, section, key));
}
case "com.microsoft.windows.system":
{
var settingId = element.GetProperty("setting_id").GetString();
var valueType = element.GetProperty("value_type").GetString();
var valueKind = Enum.Parse <SystemValueKind>(valueType, ignoreCase: true);
var handler = new SystemSettingHandlerDescription(settingId, valueKind);
try
{
var enumerator = element.GetProperty("integer_map").EnumerateArray();
var list = new List <string>();
var reverse = new Dictionary <string, long>();
long i = 0;
foreach (var child in enumerator)
{
var str = child.GetString();
list.Add(str);
reverse.Add(str, i);
++i;
}
handler.IntegerMap = list.ToArray();
handler.ReverseIntegerMap = reverse;
}
catch
{
}
return(handler);
}
case "com.microsoft.windows.files":
{
var root = element.GetProperty("root").GetString();
var files = element.GetProperty("files").EnumerateArray().Select(element => element.GetString()).ToArray();
var handler = new FilesSettingHandlerDescription(root, files);
return(handler);
}
}
}
catch
{
}
return(new SettingHandlerDescription(HandlerKind.Unknown));
}
/// <summary>
/// Register a new client handler for the given preference key
/// </summary>
/// <param name="type"></param>
/// <param name="key"></param>
public static void RegisterClientHandler(Type type, Preferences.Key key)
{
clientHandlerTypesByKey[key] = type;
}
public async Task <bool?> CaptureBool(Preferences.Key key)
{
return(await Capture(key) as bool?);
}
public async void TestRun(string[] failList, string[] crashList)
{
getCount = 0;
setCount = 0;
callCount = 0;
CaptureSessionTests.failList = failList;
CaptureSessionTests.crashList = crashList;
var services = new ServiceCollection();
services.AddLogging();
services.AddSingleton <IServiceProvider>(provider => provider);
services.AddSingleton <SettingsManager>();
services.AddSingleton <IRegistry, MockRegistry>();
services.AddSingleton <IIniFileFactory, MockIniFileFactory>();
services.AddSingleton <ISystemParametersInfo, MockSystemParametersInfo>();
services.AddSingleton <ISystemSettingFactory, MockSystemSettingFactory>();
var serviceProvider = services.BuildServiceProvider();
var settings = serviceProvider.GetRequiredService <SettingsManager>();
settings.Add(new Solution
{
Id = "org.raisingthefloor.test",
Settings = new Setting[]
{
new Setting
{
Name = "Registry Alpha",
Kind = Setting.ValueKind.Boolean,
Default = true,
HandlerDescription = new RegistrySettingHandlerDescription("Registry Alpha", "thevalue", RegistryValueKind.DWord)
},
new Setting
{
Name = "Registry Beta",
Kind = Setting.ValueKind.Integer,
Default = 52L,
HandlerDescription = new RegistrySettingHandlerDescription("Registry Beta", "thevalue", RegistryValueKind.DWord)
},
new Setting
{
Name = "Registry Gamma",
Kind = Setting.ValueKind.String,
Default = "default",
HandlerDescription = new RegistrySettingHandlerDescription("Registry Gamma", "thevalue", RegistryValueKind.String),
FinalizerDescription = new SystemParametersInfoSettingFinalizerDescription(SystemParametersInfo.Action.SetCursors)
},
new Setting
{
Name = "Ini Alpha",
Kind = Setting.ValueKind.Boolean,
Default = true,
HandlerDescription = new IniSettingHandlerDescription("thefile", "thesection", "Ini Alpha")
},
new Setting
{
Name = "Ini Beta",
Kind = Setting.ValueKind.Integer,
Default = 52L,
HandlerDescription = new IniSettingHandlerDescription("thefile", "thesection", "Ini Beta")
},
new Setting
{
Name = "Ini Gamma",
Kind = Setting.ValueKind.String,
Default = "default",
HandlerDescription = new IniSettingHandlerDescription("thefile", "thesection", "Ini Gamma"),
FinalizerDescription = new SystemParametersInfoSettingFinalizerDescription(SystemParametersInfo.Action.SetCursors)
},
new Setting
{
Name = "System Alpha",
Kind = Setting.ValueKind.String,
Default = true,
HandlerDescription = new SystemSettingHandlerDescription("System Alpha", SystemValueKind.String)
},
new Setting
{
Name = "System Beta",
Kind = Setting.ValueKind.String,
Default = 52L,
HandlerDescription = new SystemSettingHandlerDescription("System Beta", SystemValueKind.String)
},
new Setting
{
Name = "System Gamma",
Kind = Setting.ValueKind.String,
Default = "default",
HandlerDescription = new SystemSettingHandlerDescription("System Gamma", SystemValueKind.String),
FinalizerDescription = new SystemParametersInfoSettingFinalizerDescription(SystemParametersInfo.Action.SetCursors)
}
}
});
var rega = new Preferences.Key("org.raisingthefloor.test", "Registry Alpha");
var regb = new Preferences.Key("org.raisingthefloor.test", "Registry Beta");
var regc = new Preferences.Key("org.raisingthefloor.test", "Registry Gamma");
var inia = new Preferences.Key("org.raisingthefloor.test", "Ini Alpha");
var inib = new Preferences.Key("org.raisingthefloor.test", "Ini Beta");
var inic = new Preferences.Key("org.raisingthefloor.test", "Ini Gamma");
var sysa = new Preferences.Key("org.raisingthefloor.test", "System Alpha");
var sysb = new Preferences.Key("org.raisingthefloor.test", "System Beta");
var sysc = new Preferences.Key("org.raisingthefloor.test", "System Gamma");
var prefs = new Preferences();
prefs.Set(rega, "incorrect");
prefs.Set(regb, "incorrect");
prefs.Set(regc, "incorrect");
prefs.Set(inia, false);
prefs.Set(inib, 0L);
prefs.Set(inic, "incorrect");
prefs.Set(sysa, "incorrect");
prefs.Set(sysb, "incorrect");
prefs.Set(sysc, "incorrect");
var session = new CaptureSession(settings, prefs);
session.AddAllSolutions();
session.CaptureDefaultValues = true;
await session.Run();
var dict = session.Preferences.Default !["org.raisingthefloor.test"].Values;
