Made SurfaceService solely responsible for keeping the surface and the config in sync and saved

src/Artemis.Core/Models/Surface/SurfaceDeviceConfiguration.cs

@@ -64,7 +64,7 @@ namespace Artemis.Core.Models.Surface
         /// <summary>
         ///     Applies the configuration to the device
         /// </summary>
-        public void ApplyToDevice()
+        internal void ApplyToDevice()
         {
             if (Device != null)
             {

src/Artemis.Core/Services/Storage/ISurfaceService.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using Artemis.Core.Events;
 using Artemis.Core.Models.Surface;
@@ -10,9 +9,9 @@ namespace Artemis.Core.Services.Storage
     public interface ISurfaceService : IArtemisService
     {
         /// <summary>
-        ///     Gets or sets the currently active surface configuration
+        ///     Gets the currently active surface configuration, to change config use <see cref="SetActiveSurfaceConfiguration" />
         /// </summary>
-        SurfaceConfiguration ActiveSurfaceConfiguration { get; set; }
+        SurfaceConfiguration ActiveSurfaceConfiguration { get; }
 
         /// <summary>
         ///     Gets a read-only list of all surface configurations
@@ -26,26 +25,25 @@ namespace Artemis.Core.Services.Storage
         /// <returns></returns>
         SurfaceConfiguration CreateSurfaceConfiguration(string name);
 
+        /// <summary>
+        ///     Sets the provided configuration as active and applies it to the surface
+        /// </summary>
+        /// <param name="surfaceConfiguration">The configuration to activate and apply</param>
+        void SetActiveSurfaceConfiguration(SurfaceConfiguration surfaceConfiguration);
+
+        /// <summary>
+        ///     Saves the provided surface configuration to permanent storage and if config is active, applies it to the surface
+        /// </summary>
+        /// <param name="surfaceConfiguration">The configuration to save (and apply if active)</param>
+        /// <param name="includeDevices">Whether to also save devices. If false, devices changes won't be applied either</param>
+        void UpdateSurfaceConfiguration(SurfaceConfiguration surfaceConfiguration, bool includeDevices);
+
         /// <summary>
         ///     Deletes the supplied surface configuration, surface configuration may not be the active surface configuration
         /// </summary>
         /// <param name="surfaceConfiguration">The surface configuration to delete, may not be the active surface configuration</param>
         void DeleteSurfaceConfiguration(SurfaceConfiguration surfaceConfiguration);
 
-        /// <summary>
-        ///     Saves the provided surface configurations to permanent storage
-        /// </summary>
-        /// <param name="surfaceConfigurations">The configurations to save</param>
-        /// <param name="includeDevices">Whether to also save devices</param>
-        void SaveToRepository(List<SurfaceConfiguration> surfaceConfigurations, bool includeDevices);
-
-        /// <summary>
-        ///     Saves the provided surface configuration to permanent storage
-        /// </summary>
-        /// <param name="surfaceConfiguration">The configuration to save</param>
-        /// <param name="includeDevices">Whether to also save devices</param>
-        void SaveToRepository(SurfaceConfiguration surfaceConfiguration, bool includeDevices);
-
         /// <summary>
         ///     Occurs when the active device configuration has been changed
         /// </summary>

src/Artemis.Core/Services/Storage/SurfaceService.cs

@@ -18,7 +18,6 @@ namespace Artemis.Core.Services.Storage
         private readonly IRgbService _rgbService;
         private readonly List<SurfaceConfiguration> _surfaceConfigurations;
         private readonly ISurfaceRepository _surfaceRepository;
-        private SurfaceConfiguration _activeSurfaceConfiguration;
 
         public SurfaceService(ILogger logger, ISurfaceRepository surfaceRepository, IRgbService rgbService)
         {
@@ -32,37 +31,7 @@ namespace Artemis.Core.Services.Storage
             _rgbService.DeviceLoaded += RgbServiceOnDeviceLoaded;
         }
 
-        public SurfaceConfiguration ActiveSurfaceConfiguration
-        {
-            get => _activeSurfaceConfiguration;
-            set
-            {
-                if (_activeSurfaceConfiguration == value)
-                    return;
-
-                _activeSurfaceConfiguration = value;
-                lock (_surfaceConfigurations)
-                {
-                    // Mark only the new value as active
-                    foreach (var surfaceConfiguration in _surfaceConfigurations)
-                        surfaceConfiguration.IsActive = false;
-                    _activeSurfaceConfiguration.IsActive = true;
-
-                    SaveToRepository(_surfaceConfigurations, true);
-                }
-
-                // Apply the active surface configuration to the devices
-                if (ActiveSurfaceConfiguration != null)
-                {
-                    foreach (var deviceConfiguration in ActiveSurfaceConfiguration.DeviceConfigurations)
-                        deviceConfiguration.ApplyToDevice();
-                }
-                // Update the RGB service's graphics decorator to work with the new surface configuration
-                _rgbService.UpdateGraphicsDecorator();
-
-                OnActiveSurfaceConfigurationChanged(new SurfaceConfigurationEventArgs(_activeSurfaceConfiguration));
-            }
-        }
+        public SurfaceConfiguration ActiveSurfaceConfiguration { get; private set; }
 
         public ReadOnlyCollection<SurfaceConfiguration> SurfaceConfigurations
         {
@@ -90,11 +59,62 @@ namespace Artemis.Core.Services.Storage
             lock (_surfaceConfigurations)
             {
                 _surfaceRepository.Add(configuration.SurfaceEntity);
-                SaveToRepository(configuration, true);
+                UpdateSurfaceConfiguration(configuration, true);
                 return configuration;
             }
         }
 
+        public void SetActiveSurfaceConfiguration(SurfaceConfiguration surfaceConfiguration)
+        {
+            if (ActiveSurfaceConfiguration == surfaceConfiguration)
+                return;
+
+            // Set the new configuration
+            ActiveSurfaceConfiguration = surfaceConfiguration;
+
+            // Ensure only the new configuration is marked as active
+            lock (_surfaceConfigurations)
+            {
+                // Mark only the new surfaceConfiguration as active
+                foreach (var configuration in _surfaceConfigurations)
+                {
+                    configuration.IsActive = configuration == ActiveSurfaceConfiguration;
+                    configuration.ApplyToEntity();
+                }
+
+                _surfaceRepository.Save();
+            }
+
+            // Apply the active surface configuration to the devices
+            if (ActiveSurfaceConfiguration != null)
+            {
+                foreach (var deviceConfiguration in ActiveSurfaceConfiguration.DeviceConfigurations)
+                    deviceConfiguration.ApplyToDevice();
+            }
+
+            // Update the RGB service's graphics decorator to work with the new surface configuration
+            _rgbService.UpdateGraphicsDecorator();
+            OnActiveSurfaceConfigurationChanged(new SurfaceConfigurationEventArgs(ActiveSurfaceConfiguration));
+        }
+
+        public void UpdateSurfaceConfiguration(SurfaceConfiguration surfaceConfiguration, bool includeDevices)
+        {
+            surfaceConfiguration.ApplyToEntity();
+            if (includeDevices)
+            {
+                foreach (var deviceConfiguration in surfaceConfiguration.DeviceConfigurations)
+                {
+                    deviceConfiguration.ApplyToEntity();
+                    if (surfaceConfiguration.IsActive)
+                        deviceConfiguration.ApplyToDevice();
+                }
+            }
+
+            _surfaceRepository.Save();
+            _rgbService.UpdateGraphicsDecorator();
+            OnSurfaceConfigurationUpdated(new SurfaceConfigurationEventArgs(surfaceConfiguration));
+        }
+
         public void DeleteSurfaceConfiguration(SurfaceConfiguration surfaceConfiguration)
         {
             if (surfaceConfiguration == ActiveSurfaceConfiguration)
@@ -120,7 +140,7 @@ namespace Artemis.Core.Services.Storage
                     MatchDeviceConfiguration(e.Device, surfaceConfiguration);
             }
 
-            foreach (var deviceConfiguration in ActiveSurfaceConfiguration.DeviceConfigurations) 
+            foreach (var deviceConfiguration in ActiveSurfaceConfiguration.DeviceConfigurations)
                 deviceConfiguration.ApplyToDevice();
         }
 
@@ -152,33 +172,6 @@ namespace Artemis.Core.Services.Storage
                 ActiveSurfaceConfiguration = active;
         }
 
-        public void SaveToRepository(List<SurfaceConfiguration> surfaceConfigurations, bool includeDevices)
-        {
-            foreach (var surfaceConfiguration in surfaceConfigurations)
-            {
-                surfaceConfiguration.ApplyToEntity();
-                if (!includeDevices)
-                {
-                    foreach (var deviceConfiguration in surfaceConfiguration.DeviceConfigurations)
-                        deviceConfiguration.ApplyToEntity();
-                }
-            }
-
-            _surfaceRepository.Save();
-        }
-
-        public void SaveToRepository(SurfaceConfiguration surfaceConfiguration, bool includeDevices)
-        {
-            surfaceConfiguration.ApplyToEntity();
-            if (includeDevices)
-            {
-                foreach (var deviceConfiguration in surfaceConfiguration.DeviceConfigurations)
-                    deviceConfiguration.ApplyToEntity();
-            }
-
-            _surfaceRepository.Save();
-        }
-
         #endregion
 
         #region Utilities
@@ -217,12 +210,18 @@ namespace Artemis.Core.Services.Storage
         #region Events
 
         public event EventHandler<SurfaceConfigurationEventArgs> ActiveSurfaceConfigurationChanged;
+        public event EventHandler<SurfaceConfigurationEventArgs> SurfaceConfigurationUpdated;
 
         protected virtual void OnActiveSurfaceConfigurationChanged(SurfaceConfigurationEventArgs e)
         {
             ActiveSurfaceConfigurationChanged?.Invoke(this, e);
         }
 
+        protected virtual void OnSurfaceConfigurationUpdated(SurfaceConfigurationEventArgs e)
+        {
+            SurfaceConfigurationUpdated?.Invoke(this, e);
+        }
+
         #endregion
     }
 }