SettingsService.cs

using Waher.Persistence;
using Waher.Runtime.Inventory;
using Waher.Runtime.Settings;
 
namespace NeuroAccessMaui.Services.Settings
{
    [Singleton]
    internal sealed class SettingsService : ISettingsService
    {
        public SettingsService()
        {
        }
 
        private static void AssertNonEmptyPRefix(string KeyPrefix)
        {
            if (string.IsNullOrWhiteSpace(KeyPrefix))
                throw new ArgumentException("Empty key prefix not permitted.", nameof(KeyPrefix));
        }
 
        public async Task SaveState(string Key, string State)
        {
            try
            {
                await RuntimeSettings.SetAsync(Key, State);
                await Database.Provider.Flush();
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
            }
        }
 
        public async Task SaveState(string Key, long State)
        {
            try
            {
                await RuntimeSettings.SetAsync(Key, State);
                await Database.Provider.Flush();
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
            }
        }
 
        public async Task SaveState(string Key, double State)
        {
            try
            {
                await RuntimeSettings.SetAsync(Key, State);
                await Database.Provider.Flush();
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
            }
        }
 
        public async Task SaveState(string Key, bool State)
        {
            try
            {
                await RuntimeSettings.SetAsync(Key, State);
                await Database.Provider.Flush();
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
            }
        }
 
        public async Task SaveState(string Key, DateTime State)
        {
            try
            {
                await RuntimeSettings.SetAsync(Key, State);
                await Database.Provider.Flush();
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
            }
        }
 
        public async Task SaveState(string Key, TimeSpan State)
        {
            try
            {
                await RuntimeSettings.SetAsync(Key, State);
                await Database.Provider.Flush();
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
            }
        }
 
        public async Task SaveState(string Key, Enum State)
        {
            try
            {
                await RuntimeSettings.SetAsync(Key, State);
                await Database.Provider.Flush();
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
            }
        }
 
        public async Task SaveState(string Key, object State)
        {
            try
            {
                await RuntimeSettings.SetAsync(Key, State);
                await Database.Provider.Flush();
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
            }
        }
 
        public async Task<string?> RestoreStringState(string Key, string? DefaultValueIfNotFound = default)
        {
            try
            {
                return await RuntimeSettings.GetAsync(Key, DefaultValueIfNotFound);
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
            }
 
            return DefaultValueIfNotFound;
        }
 
        public async Task<long> RestoreLongState(string Key, long DefaultValueIfNotFound = default)
        {
            try
            {
                return await RuntimeSettings.GetAsync(Key, DefaultValueIfNotFound);
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
            }
 
            return DefaultValueIfNotFound;
        }
 
        public async Task<double> RestoreDoubleState(string Key, double DefaultValueIfNotFound = default)
        {
            try
            {
                return await RuntimeSettings.GetAsync(Key, DefaultValueIfNotFound);
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
            }
 
            return DefaultValueIfNotFound;
        }
 
        public async Task<bool> RestoreBoolState(string Key, bool DefaultValueIfNotFound = default)
        {
            try
            {
                return await RuntimeSettings.GetAsync(Key, DefaultValueIfNotFound);
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
            }
 
            return DefaultValueIfNotFound;
        }
 
        public async Task<DateTime> RestoreDateTimeState(string Key, DateTime DefaultValueIfNotFound = default)
        {
            try
            {
                return await RuntimeSettings.GetAsync(Key, DefaultValueIfNotFound);
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
            }
 
            return DefaultValueIfNotFound;
        }
 
        public async Task<TimeSpan> RestoreTimeSpanState(string Key, TimeSpan DefaultValueIfNotFound = default)
        {
            try
            {
                return await RuntimeSettings.GetAsync(Key, DefaultValueIfNotFound);
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
            }
 
            return DefaultValueIfNotFound;
        }
 
        public async Task<Enum?> RestoreEnumState(string Key, Enum? DefaultValueIfNotFound = default)
        {
            try
            {
                return await RuntimeSettings.GetAsync(Key, DefaultValueIfNotFound);
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
            }
 
            return DefaultValueIfNotFound;
        }
 
        public async Task<T?> RestoreState<T>(string Key, T? DefaultValueIfNotFound = default)
        {
            if (string.IsNullOrWhiteSpace(Key))
                return DefaultValueIfNotFound;
 
            try
            {
                object existingState = await RuntimeSettings.GetAsync(Key, (object?)null);
 
                if (existingState is T TypedValue)
                    return TypedValue;
 
                return DefaultValueIfNotFound;
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
            }
 
            return DefaultValueIfNotFound;
        }
 
        public async Task RemoveState(string Key)
        {
            AssertNonEmptyPRefix(Key);
 
            try
            {
                await RuntimeSettings.DeleteAsync(Key);
                await Database.Provider.Flush();
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
            }
        }
 
        public Task<bool> WaitInitDone()
        {
            return ServiceRef.StorageService.WaitInitDone();
        }
    }
}