Use Dependency Injection

.gitignore

@@ -351,4 +351,5 @@ ASALocalRun/
 .localhistory/
 
 # BeatPulse healthcheck temp database
-healthchecksdb
+healthchecksdb
+.vscode/settings.json

userinterface/App.axaml.cs

@@ -2,9 +2,12 @@
 using Avalonia.Controls.ApplicationLifetimes;
 using Avalonia.Data.Core.Plugins;
 using Avalonia.Markup.Xaml;
+using Microsoft.Extensions.DependencyInjection;
+using System;
 using userinterface.ViewModels;
 using userinterface.Views;
 using userspace_backend;
+using userspace_backend.IO;
 using DATA = userspace_backend.Data;
 
 namespace userinterface;
@@ -18,7 +21,24 @@ public override void Initialize()
 
     public override void OnFrameworkInitializationCompleted()
     {
-        BackEnd backEnd = new BackEnd(BootstrapBackEnd());
+        // Create the DI container
+        ServiceCollection services = new ServiceCollection();
+
+        // Register BackEndLoader first with settings directory
+        string settingsDirectory = System.AppDomain.CurrentDomain.BaseDirectory;
+        services.AddSingleton<IBackEndLoader>(sp =>
+        {
+            var devicesRW = sp.GetRequiredService<DevicesReaderWriter>();
+            var mappingsRW = sp.GetRequiredService<MappingsReaderWriter>();
+            var profileRW = sp.GetRequiredService<ProfileReaderWriter>();
+            return new BackEndLoader(settingsDirectory, devicesRW, mappingsRW, profileRW);
+        });
+
+        // Compose all other services
+        IServiceProvider serviceProvider = BackEndComposer.Compose(services);
+
+        // Resolve and initialize BackEnd
+        IBackEnd backEnd = serviceProvider.GetRequiredService<IBackEnd>();
         backEnd.Load();
 
         if (ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
@@ -44,7 +64,11 @@ protected Bootstrapper BootstrapBackEnd()
     {
         return new Bootstrapper()
         {
-            BackEndLoader = new BackEndLoader(System.AppDomain.CurrentDomain.BaseDirectory),
+            BackEndLoader = new BackEndLoader(
+                System.AppDomain.CurrentDomain.BaseDirectory,
+                new DevicesReaderWriter(),
+                new MappingsReaderWriter(),
+                new ProfileReaderWriter()),
             DevicesToLoad =
             [
                 new DATA.Device() { Name = "Superlight 2", DPI = 32000, HWID = @"HID\VID_046D&PID_C54D&MI_00", PollingRate = 1000, DeviceGroup = "Logitech Mice" },

userinterface/ViewModels/Device/DeviceGroupSelectorViewModel.cs

@@ -5,29 +5,29 @@ namespace userinterface.ViewModels.Device
 {
     public partial class DeviceGroupSelectorViewModel : ViewModelBase
     {
-        protected DeviceGroupModel selectedEntry = null!;
+        protected string selectedEntry = null!;
 
-        public DeviceGroupSelectorViewModel(DeviceModel device, DeviceGroups deviceGroupsBE)
+        public DeviceGroupSelectorViewModel(IDeviceModel device, DeviceGroups deviceGroupsBE)
         {
             Device = device;
             DeviceGroupsBE = deviceGroupsBE;
             RefreshSelectedDeviceGroup();
         }
 
-        protected DeviceModel Device { get; }
+        protected IDeviceModel Device { get; }
         protected DeviceGroups DeviceGroupsBE { get; }
 
-        public ObservableCollection<DeviceGroupModel> DeviceGroupEntries =>
+        public ObservableCollection<string> DeviceGroupEntries =>
             DeviceGroupsBE.DeviceGroupModels;
 
-        public DeviceGroupModel SelectedEntry
+        public string SelectedEntry
         {
             get => selectedEntry;
             set
             {
                 if (DeviceGroupEntries.Contains(value))
                 {
-                    Device.DeviceGroup = value;
+                    Device.DeviceGroup.TryUpdateModelDirectly(value);
                     selectedEntry = value;
                 }
             }
@@ -37,15 +37,15 @@ public DeviceGroupModel SelectedEntry
 
         public void RefreshSelectedDeviceGroup()
         {
-            if (!DeviceGroupEntries.Contains(Device.DeviceGroup))
+            if (!DeviceGroupEntries.Contains(Device.DeviceGroup.ModelValue))
             {
                 IsValid = false;
                 SelectedEntry = DeviceGroups.DefaultDeviceGroup;
                 return;
             }
 
             IsValid = true;
-            selectedEntry = Device.DeviceGroup;
+            selectedEntry = Device.DeviceGroup.ModelValue;
         }
     }
 }

userinterface/ViewModels/Device/DeviceGroupViewModel.cs

@@ -5,13 +5,13 @@ namespace userinterface.ViewModels.Device
 {
     public partial class DeviceGroupViewModel : ViewModelBase
     {
-        public DeviceGroupViewModel(BE.DeviceGroupModel deviceGroupBE, BE.DeviceGroups deviceGroupsBE)
+        public DeviceGroupViewModel(string deviceGroupBE, BE.DeviceGroups deviceGroupsBE)
         {
             DeviceGroupBE = deviceGroupBE;
             DeviceGroupsBE = deviceGroupsBE;
         }
 
-        public BE.DeviceGroupModel DeviceGroupBE { get; }
+        public string DeviceGroupBE { get; }
 
         protected BE.DeviceGroups DeviceGroupsBE { get; }
 

userinterface/ViewModels/Device/DeviceGroupsViewModel.cs

@@ -16,17 +16,17 @@ public DeviceGroupsViewModel(BE.DeviceGroups deviceGroupsBE)
 
         protected BE.DeviceGroups DeviceGroupsBE { get; }
 
-        public ObservableCollection<BE.DeviceGroupModel> DeviceGroups => DeviceGroupsBE.DeviceGroupModels;
+        public ObservableCollection<string> DeviceGroups => DeviceGroupsBE.DeviceGroupModels;
 
         public ObservableCollection<DeviceGroupViewModel> DeviceGroupViews { get; }
 
-        private void DeviceGroupsCollectionChanged(object? sender, NotifyCollectionChangedEventArgs e) => 
+        private void DeviceGroupsCollectionChanged(object? sender, NotifyCollectionChangedEventArgs e) =>
             UpdateDeviceGroupViews();
 
         public void UpdateDeviceGroupViews()
         {
             DeviceGroupViews.Clear();
-            foreach (BE.DeviceGroupModel deviceGroup in DeviceGroupsBE.DeviceGroupModels)
+            foreach (string deviceGroup in DeviceGroupsBE.DeviceGroupModels)
             {
                 DeviceGroupViews.Add(new DeviceGroupViewModel(deviceGroup, DeviceGroupsBE));
             }

userinterface/ViewModels/Device/DeviceViewModel.cs

@@ -6,7 +6,7 @@ namespace userinterface.ViewModels.Device
 {
     public partial class DeviceViewModel : ViewModelBase
     {
-        public DeviceViewModel(BE.DeviceModel deviceBE, BE.DevicesModel devicesBE)
+        public DeviceViewModel(BE.IDeviceModel deviceBE, BE.DevicesModel devicesBE)
         {
             DeviceBE = deviceBE;
             DevicesBE = devicesBE;
@@ -18,7 +18,7 @@ public DeviceViewModel(BE.DeviceModel deviceBE, BE.DevicesModel devicesBE)
             DeviceGroup = new DeviceGroupSelectorViewModel(DeviceBE, DevicesBE.DeviceGroups);
         }
 
-        protected BE.DeviceModel DeviceBE { get; }
+        protected BE.IDeviceModel DeviceBE { get; }
 
         protected BE.DevicesModel DevicesBE { get; }
 
@@ -36,7 +36,7 @@ public DeviceViewModel(BE.DeviceModel deviceBE, BE.DevicesModel devicesBE)
 
         public void DeleteSelf()
         {
-            bool success = DevicesBE.RemoveDevice(DeviceBE);
+            bool success = DevicesBE.TryRemoveElement(DeviceBE);
             Debug.Assert(success);
         }
     }

userinterface/ViewModels/Device/DevicesListViewModel.cs

@@ -11,12 +11,12 @@ public DevicesListViewModel(BE.DevicesModel devicesBE)
             DevicesBE = devicesBE;
             DeviceViews = [];
             UpdateDeviceViews();
-            DevicesBE.Devices.CollectionChanged += DevicesCollectionChanged;
+            ((INotifyCollectionChanged)DevicesBE.Elements).CollectionChanged += DevicesCollectionChanged;
         }
 
         protected BE.DevicesModel DevicesBE { get; }
 
-        public ObservableCollection<BE.DeviceModel> Devices => DevicesBE.Devices;
+        public ReadOnlyObservableCollection<BE.IDeviceModel> Devices => DevicesBE.Elements;
 
         public ObservableCollection<DeviceViewModel> DeviceViews { get; }
 
@@ -26,12 +26,12 @@ private void DevicesCollectionChanged(object? sender, NotifyCollectionChangedEve
         public void UpdateDeviceViews()
         {
             DeviceViews.Clear();
-            foreach (BE.DeviceModel device in DevicesBE.Devices)
+            foreach (BE.IDeviceModel device in DevicesBE.Elements)
             {
                 DeviceViews.Add(new DeviceViewModel(device, DevicesBE));
             }
         }
 
-        public bool TryAddDevice() => DevicesBE.TryAddDevice();
+        public bool TryAddDevice() => DevicesBE.TryAddNewDefault();
     }
 }

userinterface/ViewModels/MainWindowViewModel.cs

@@ -16,7 +16,7 @@ public partial class MainWindowViewModel : ViewModelBase, INotifyPropertyChanged
 
     private string _selectedPage = DefaultPage;
 
-    public MainWindowViewModel(BE.BackEnd backEnd)
+    public MainWindowViewModel(BE.IBackEnd backEnd)
     {
         BackEnd = backEnd;
         DevicesPage = new DevicesPageViewModel(backEnd.Devices);
@@ -30,7 +30,7 @@ public MainWindowViewModel(BE.BackEnd backEnd)
 
     public MappingsPageViewModel MappingsPage { get; }
 
-    protected BE.BackEnd BackEnd { get; }
+    protected BE.IBackEnd BackEnd { get; }
 
     public string SelectedPage
     {

userinterface/ViewModels/Mapping/MappingViewModel.cs

@@ -21,9 +21,11 @@ public MappingViewModel(BE.MappingModel mappingBE, BE.MappingsModel mappingsBE)
 
         public void HandleAddMappingSelection(SelectionChangedEventArgs e)
         {
-            if (e.AddedItems.Count > 0 && e.AddedItems[0] is BE.DeviceGroupModel deviceGroup)
+            if (e.AddedItems.Count > 0 && e.AddedItems[0] is string deviceGroup)
             {
-                MappingBE.TryAddMapping(deviceGroup.CurrentValidatedValue, BE.ProfilesModel.DefaultProfile.CurrentNameForDisplay);
+                // TODO: re-add default profile
+                // MappingBE.TryAddMapping(deviceGroup, BE.ProfilesModel.DefaultProfile.CurrentNameForDisplay);
+                MappingBE.TryAddMapping(deviceGroup, "Default");
             }
         }
 

userinterface/ViewModels/Profile/AccelerationFormulaSettingsViewModel.cs

@@ -14,30 +14,30 @@ public class AccelerationFormulaSettingsViewModel : ViewModelBase
                 .Cast<BEData.AccelerationFormulaType>()
                 .Select(formulaType => formulaType.ToString()));
 
-        public AccelerationFormulaSettingsViewModel(BE.FormulaAccelModel formulaAccel)
+        public AccelerationFormulaSettingsViewModel(BE.IFormulaAccelModel formulaAccel)
         {
             FormulaAccelBE = formulaAccel;
 
-            SynchronousSettings = new SynchronousSettings((formulaAccel.GetAccelerationModelOfType(BEData.AccelerationFormulaType.Synchronous)
-                as BE.Formula.SynchronousAccelerationDefinitionModel)!);
+            SynchronousSettings = new SynchronousSettings((formulaAccel.GetSelectable(BEData.AccelerationFormulaType.Synchronous)
+                as BE.Formula.ISynchronousAccelerationDefinitionModel)!);
 
-            LinearSettings = new LinearSettings((formulaAccel.GetAccelerationModelOfType(BEData.AccelerationFormulaType.Linear)
+            LinearSettings = new LinearSettings((formulaAccel.GetSelectable(BEData.AccelerationFormulaType.Linear)
                 as BE.Formula.LinearAccelerationDefinitionModel)!);
 
-            ClassicSettings = new ClassicSettings((formulaAccel.GetAccelerationModelOfType(BEData.AccelerationFormulaType.Classic)
+            ClassicSettings = new ClassicSettings((formulaAccel.GetSelectable(BEData.AccelerationFormulaType.Classic)
                 as BE.Formula.ClassicAccelerationDefinitionModel)!);
 
-            PowerSettings = new PowerSettings((formulaAccel.GetAccelerationModelOfType(BEData.AccelerationFormulaType.Power)
+            PowerSettings = new PowerSettings((formulaAccel.GetSelectable(BEData.AccelerationFormulaType.Power)
                 as BE.Formula.PowerAccelerationDefinitionModel)!);
 
-            NaturalSettings = new NaturalSettings((formulaAccel.GetAccelerationModelOfType(BEData.AccelerationFormulaType.Natural)
+            NaturalSettings = new NaturalSettings((formulaAccel.GetSelectable(BEData.AccelerationFormulaType.Natural)
                 as BE.Formula.NaturalAccelerationDefinitionModel)!);
 
-            JumpSettings = new JumpSettings((formulaAccel.GetAccelerationModelOfType(BEData.AccelerationFormulaType.Jump)
+            JumpSettings = new JumpSettings((formulaAccel.GetSelectable(BEData.AccelerationFormulaType.Jump)
                 as BE.Formula.JumpAccelerationDefinitionModel)!);
         }
 
-        public BE.FormulaAccelModel FormulaAccelBE { get; }
+        public BE.IFormulaAccelModel FormulaAccelBE { get; }
 
         public ObservableCollection<string> FormulaTypesLocal => FormulaTypes;
 
@@ -56,7 +56,7 @@ public AccelerationFormulaSettingsViewModel(BE.FormulaAccelModel formulaAccel)
 
     public class SynchronousSettings
     {
-        public SynchronousSettings(BE.Formula.SynchronousAccelerationDefinitionModel synchronousAccelModelBE)
+        public SynchronousSettings(BE.Formula.ISynchronousAccelerationDefinitionModel synchronousAccelModelBE)
         {
             SyncSpeed = new EditableFieldViewModel(synchronousAccelModelBE.SyncSpeed);
             Motivity = new EditableFieldViewModel(synchronousAccelModelBE.Motivity);

userinterface/ViewModels/Profile/AccelerationLUTSettingsViewModel.cs

@@ -5,13 +5,13 @@ namespace userinterface.ViewModels.Profile
 {
     public partial class AccelerationLUTSettingsViewModel : ViewModelBase
     {
-        public AccelerationLUTSettingsViewModel(BE.LookupTableDefinitionModel lutAccelBE)
+        public AccelerationLUTSettingsViewModel(BE.ILookupTableDefinitionModel lutAccelBE)
         {
             LUTAccelBE = lutAccelBE;
             LUTPoints = new EditableFieldViewModel(lutAccelBE.Data);
         }
 
-        public BE.LookupTableDefinitionModel LUTAccelBE { get; }
+        public BE.ILookupTableDefinitionModel LUTAccelBE { get; }
 
         public EditableFieldViewModel LUTPoints { get; set; }
     }

userinterface/ViewModels/Profile/AccelerationProfileSettingsViewModel.cs

@@ -18,18 +18,21 @@ public partial class AccelerationProfileSettingsViewModel : ViewModelBase
         [ObservableProperty]
         public bool areAccelSettingsVisible;
 
-        public AccelerationProfileSettingsViewModel(BE.AccelerationModel accelerationBE)
+        public AccelerationProfileSettingsViewModel(BE.IAccelerationModel accelerationBE)
         {
             AccelerationBE = accelerationBE;
-            AccelerationFormulaSettings = new AccelerationFormulaSettingsViewModel(accelerationBE.FormulaAccel);
-            AccelerationLUTSettings = new AccelerationLUTSettingsViewModel(accelerationBE.LookupTableAccel);
+            AccelerationFormulaSettings = new AccelerationFormulaSettingsViewModel(
+                accelerationBE.GetSelectable(BEData.AccelerationDefinitionType.Formula) as BE.IFormulaAccelModel);
+            AccelerationLUTSettings = new AccelerationLUTSettingsViewModel(
+                accelerationBE.GetSelectable(BEData.AccelerationDefinitionType.LookupTable) as BE.ILookupTableDefinitionModel);
             AnisotropySettings = new AnisotropyProfileSettingsViewModel(accelerationBE.Anisotropy);
             CoalescionSettings = new CoalescionProfileSettingsViewModel(accelerationBE.Coalescion);
-            AccelerationBE.DefinitionType.AutoUpdateFromInterface = true;
-            AccelerationBE.DefinitionType.PropertyChanged += OnDefinitionTypeChanged;
+            // TODO: editable settings composition
+            AccelerationBE.Selection.AutoUpdateFromInterface = true;
+            AccelerationBE.Selection.PropertyChanged += OnDefinitionTypeChanged;
         }
 
-        public BE.AccelerationModel AccelerationBE { get; }
+        public BE.IAccelerationModel AccelerationBE { get; }
 
         public ObservableCollection<string> DefinitionTypesLocal => DefinitionTypes;
 
@@ -43,9 +46,9 @@ public AccelerationProfileSettingsViewModel(BE.AccelerationModel accelerationBE)
 
         private void OnDefinitionTypeChanged(object? sender, PropertyChangedEventArgs e)
         {
-            if (e.PropertyName == nameof(AccelerationBE.DefinitionType.CurrentValidatedValue))
+            if (e.PropertyName == nameof(AccelerationBE.Selection.ModelValue))
             {
-                AreAccelSettingsVisible = AccelerationBE.DefinitionType.ModelValue != BEData.AccelerationDefinitionType.None;
+                AreAccelSettingsVisible = AccelerationBE.Selection.ModelValue != BEData.AccelerationDefinitionType.None;
             }
         }
     }

userinterface/ViewModels/Profile/AnisotropyProfileSettingsViewModel.cs

@@ -5,7 +5,7 @@ namespace userinterface.ViewModels.Profile
 {
     public partial class AnisotropyProfileSettingsViewModel : ViewModelBase
     {
-        public AnisotropyProfileSettingsViewModel(BE.AnisotropyModel anisotropyBE)
+        public AnisotropyProfileSettingsViewModel(BE.IAnisotropyModel anisotropyBE)
         {
             AnisotropyBE = anisotropyBE;
             DomainX = new EditableFieldViewModel(AnisotropyBE.DomainX);
@@ -15,7 +15,7 @@ public AnisotropyProfileSettingsViewModel(BE.AnisotropyModel anisotropyBE)
             LPNorm = new NamedEditableFieldViewModel(AnisotropyBE.LPNorm);
         }
 
-        protected BE.AnisotropyModel AnisotropyBE { get; }
+        protected BE.IAnisotropyModel AnisotropyBE { get; }
 
         public EditableFieldViewModel DomainX { get; set; }
 

userinterface/ViewModels/Profile/CoalescionProfileSettingsViewModel.cs

@@ -5,14 +5,14 @@ namespace userinterface.ViewModels.Profile
 {
     public partial class CoalescionProfileSettingsViewModel : ViewModelBase
     {
-        public CoalescionProfileSettingsViewModel(BE.CoalescionModel coalescionBE)
+        public CoalescionProfileSettingsViewModel(BE.ICoalescionModel coalescionBE)
         {
             CoalescionBE = coalescionBE;
             InputSmoothingHalfLife = new EditableFieldViewModel(coalescionBE.InputSmoothingHalfLife);
             ScaleSmoothingHalfLife = new EditableFieldViewModel(coalescionBE.ScaleSmoothingHalfLife);
         }
 
-        protected BE.CoalescionModel CoalescionBE { get; }
+        protected BE.ICoalescionModel CoalescionBE { get; }
 
         public EditableFieldViewModel InputSmoothingHalfLife { get; set; }
 

userinterface/ViewModels/Profile/HiddenProfileSettingsViewModel.cs

@@ -5,7 +5,7 @@ namespace userinterface.ViewModels.Profile
 {
     public partial class HiddenProfileSettingsViewModel : ViewModelBase
     {
-        public HiddenProfileSettingsViewModel(BE.ProfileComponents.HiddenModel hiddenBE)
+        public HiddenProfileSettingsViewModel(BE.ProfileComponents.IHiddenModel hiddenBE)
         {
             HiddenBE = hiddenBE;
             RotationField = new EditableFieldViewModel(hiddenBE.RotationDegrees);
@@ -16,7 +16,7 @@ public HiddenProfileSettingsViewModel(BE.ProfileComponents.HiddenModel hiddenBE)
             OutputSmoothingHalfLifeField = new EditableFieldViewModel(hiddenBE.OutputSmoothingHalfLife);
         }
 
-        protected BE.ProfileComponents.HiddenModel HiddenBE { get; }
+        protected BE.ProfileComponents.IHiddenModel HiddenBE { get; }
 
         public EditableFieldViewModel RotationField { get; set; }