/// <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;