Custom animation

Winleafs.Api/Endpoints/EffectsEndpoint.cs

@@ -55,7 +55,6 @@ public void SetSelectedEffect(string effectName)
             SendRequest(BaseUrl, Method.PUT, body: new { select = effectName});
         }
 
-
         /// <inheritdoc />
         public Task<Effect> GetEffectDetailsAsync(string effectName)
         {
@@ -78,6 +77,18 @@ public Effect GetEffectDetails(string effectName)
             return SendRequest<Effect>(BaseUrl, Method.PUT, CreateWriteEffectCommand(effectName));
         }
 
+        /// <inheritdoc />
+        public void WriteCustomEffectCommand(CustomEffectCommand customEffectCommand)
+        {
+            SendRequest(BaseUrl, Method.PUT, body: CreateWriteAnimationCommand(customEffectCommand));
+        }
+
+        /// <inheritdoc />
+        public async Task WriteCustomEffectCommandAsync(CustomEffectCommand customEffectCommand)
+        {
+            await SendRequestAsync(BaseUrl, Method.PUT, body: CreateWriteAnimationCommand(customEffectCommand));
+        }
+
         private static object CreateWriteEffectCommand(string effectName)
         {
             return new
@@ -89,5 +100,13 @@ private static object CreateWriteEffectCommand(string effectName)
                 }
             };
         }
+
+        private static object CreateWriteAnimationCommand(CustomEffectCommand customAnimationCommand)
+        {
+            return new
+            {
+                write = customAnimationCommand
+            };
+        }
     }
 }

Winleafs.Api/Endpoints/Interfaces/IEffectsEndpoint.cs

@@ -44,5 +44,15 @@ public interface IEffectsEndpoint
 
 	    /// <inheritdoc cref="GetEffectDetailsAsync"/>
 		Effect GetEffectDetails(string effectName);
+
+        /// <summary>
+        /// Send a command for a custom effect.
+        /// </summary>
+        /// <param name="customAnimationCommand">The custom effect command to be sent.</param>
+        /// <returns>The details about the effect.</returns>
+        Task WriteCustomEffectCommandAsync(CustomEffectCommand customEffectCommand);
+
+        /// <inheritdoc cref="WriteCustomEffectCommandAsync"/>
+        void WriteCustomEffectCommand(CustomEffectCommand customEffectCommand);
     }
 }

Winleafs.Api/Endpoints/NanoleafEndpoint.cs

@@ -4,6 +4,7 @@
 using Newtonsoft.Json;
 using NLog;
 using RestSharp;
+using RestSharp.Serializers.NewtonsoftJson;
 
 namespace Winleafs.Api.Endpoints
 {
@@ -60,6 +61,8 @@ protected async Task<object> SendRequestAsync(string endpoint, Method method,
             Type returnType = null, object body = null, bool disableLogging = false)
         {
             var restClient = new RestClient(Client.BaseUri);
+            restClient.UseNewtonsoftJson();
+
             var request = new RestRequest(GetUrlForRequest(endpoint), method)
             {
                 Timeout = Timeout
@@ -97,6 +100,8 @@ protected async Task<object> SendRequestAsync(string endpoint, Method method,
         protected object SendRequest(string endpoint, Method method, Type returnType = null, object body = null, bool disableLogging = false)
         {
             var restClient = new RestClient(Client.BaseUri);
+            restClient.UseNewtonsoftJson();
+
             var request = new RestRequest(GetUrlForRequest(endpoint), method)
             {
                 Timeout = Timeout //Set timeout to 2 seconds

Winleafs.Api/Winleafs.Api.csproj

@@ -12,6 +12,7 @@
     <PackageReference Include="NLog" Version="4.7.10" />
     <PackageReference Include="Polly" Version="7.2.2" />
     <PackageReference Include="RestSharp" Version="106.12.0" />
+    <PackageReference Include="RestSharp.Serializers.NewtonsoftJson" Version="106.12.0" />
   </ItemGroup>
 
   <ItemGroup>

Winleafs.Models/Models/Device.cs

@@ -39,6 +39,8 @@ public class Device
 
         public PercentageProfile PercentageProfile { get;set;}
 
+        public CustomEffect CustomEffect { get; set; }
+
         public ScreenMirrorAlgorithm ScreenMirrorAlgorithm { get; set; }
 
         public ScreenMirrorFlip ScreenMirrorFlip { get; set; }

Winleafs.Models/Models/Effects/CustomEffectCommand.cs

@@ -0,0 +1,59 @@
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Winleafs.Models.Models.Effects
+{
+    public class CustomEffectCommand
+    {
+        /// <summary>
+        /// The command can be either be add, update or display:
+        /// add - will create a new custom effect, or update one if it has the same animName
+        /// update - will update an existing effect with the same animName
+        /// display - will show the effect on the device but will not save it
+        /// </summary>
+        [JsonProperty("command")]
+        public string Command { get; set; } 
+
+        /// <summary>
+        /// The version of the JSON schema.
+        /// </summary>
+        [JsonProperty("version")]
+        public string Version { get; } = "1.0";
+
+        /// <summary>
+        /// The name of the custom effect
+        /// </summary>
+        [JsonProperty("animName")]
+        public string AnimName { get; set; }
+
+        /// <summary>
+        /// The type of animation, can be either custom or static.
+        /// </summary>
+        [JsonProperty("animType")]
+        public string AnimType { get; set; }
+
+        /// <summary>
+        /// A data structure that specifies the speed at which frames transition from coor to color. 
+        /// See 3.2.6.1 Custom effect at https://forum.nanoleaf.me/docs/openapi for more information.
+        /// </summary>
+        [JsonProperty("animData")]
+        public string AnimData { get; set; }
+
+        /// <summary>
+        /// Determines whether the custom effect will repeat.
+        /// </summary>
+        [JsonProperty("loop")]
+        public bool Loop { get; set; }
+
+        /// <summary>
+        /// This has no functional use for the custom effect, it just sets
+        /// the colors to be displayed in apps that list the effect. 
+        /// </summary>
+        [JsonProperty("palette")]
+        public IList<Palette> Palette { get; set; } = new List<Palette>();
+    }
+}

Winleafs.Models/Models/Layouts/CustomEffect.cs

@@ -0,0 +1,30 @@
+using System.Collections.Generic;
+
+namespace Winleafs.Models.Models.Layouts
+{
+    /// <summary>
+    /// A user created Custom Effect which specifies a static pattern or animation
+    /// </summary>
+    public class CustomEffect
+    {
+        /// <summary>
+        /// True if this is just one Frame to set each panel's color
+        /// </summary>
+        public bool IsStatic { get; set; }
+
+        /// <summary>
+        /// True if the animation is played repeatedly
+        /// </summary>
+        public bool IsLoop { get; set; }
+
+        /// <summary>
+        /// A series of frames each specifying the color for each panel
+        /// </summary>
+        public IList<Frame> Frames { get; set; }
+
+        public CustomEffect()
+        {
+            Frames = new List<Frame>();
+        }
+    }
+}

Winleafs.Models/Models/Layouts/Frame.cs

@@ -0,0 +1,14 @@
+using System.Collections.Generic;
+
+namespace Winleafs.Models.Models.Layouts
+{
+    public class Frame
+    {
+        public IDictionary<int, uint> PanelColors { get; set; }
+
+        public Frame()
+        {
+            PanelColors = new Dictionary<int, uint>();
+        }
+    }
+}

Winleafs.Models/Models/Layouts/FrameListItem.cs

@@ -0,0 +1,17 @@
+using Winleafs.Models.Models.Layouts;
+
+namespace Winleafs.Models.Models.Layouts
+{
+	public class FrameListItem
+	{
+		public FrameListItem(Frame frame, string name)
+		{
+			Frame = frame;
+			Name = name;
+		}
+
+		public string Name { get; set; }
+		public Frame Frame { get; set; }
+	}
+}
+

Winleafs.Wpf/Api/Effects/CustomEffectCommandBuilder.cs

@@ -0,0 +1,137 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Winleafs.Models.Models.Effects;
+using Winleafs.Models.Models.Layouts;
+using Winleafs.Wpf.Helpers;
+
+namespace Winleafs.Wpf.Api.Effects
+{
+	/// <summary>
+	/// Used to build a CustomEffectCommand to send to the API
+	/// </summary>
+	public class CustomEffectCommandBuilder
+	{
+		private readonly CustomEffect _customEffect;
+		private int _transitionTime;
+
+		public CustomEffectCommandBuilder(CustomEffect customEffect)
+		{
+			_customEffect = customEffect;
+		}
+
+		public CustomEffectCommand BuildAddCommand(float transitionSecs, string name)
+		{
+			//If a name has been passed the custom effect will be added to the device
+			var customEffectCommand = new CustomEffectCommand();
+			customEffectCommand.Command = "add";
+			customEffectCommand.AnimName = name;
+
+			//Convert seconds to tenths of a second, the time unit used by commands
+			_transitionTime = (int)Math.Floor(transitionSecs * 10);
+
+			BuildBody(customEffectCommand);
+
+			return customEffectCommand;
+		}
+
+		public CustomEffectCommand BuildDisplayCommand(float transitionSecs)
+		{
+			//If no name has been passed the custom effect will just be dispayed on the device
+			var customEffectCommand = new CustomEffectCommand();
+			customEffectCommand.Command = "display";
+
+			//Convert seconds to tenths of a second, the time unit used by commands
+			_transitionTime = (int)Math.Floor(transitionSecs * 10);
+
+			BuildBody(customEffectCommand);
+
+			return customEffectCommand;
+		}
+
+		private void BuildBody(CustomEffectCommand customEffectCommand)
+		{
+			if (_customEffect.IsStatic)
+			{
+				customEffectCommand.AnimType = "static";
+			}
+			else
+			{
+				customEffectCommand.AnimType = "custom";
+				customEffectCommand.Loop = _customEffect.IsLoop;
+			}
+
+			var animData = new StringBuilder();
+			animData.Append(_customEffect.Frames[0].PanelColors.Count);
+
+			foreach (var panelId in _customEffect.Frames[0].PanelColors.Keys)
+			{
+				animData.Append(BuildPanelAnimData(panelId));
+			}
+
+			customEffectCommand.AnimData = animData.ToString();
+
+			//Set pallete so used colurs are displayed in apps (docs say max of 20)
+			var rgbs = _customEffect.Frames.SelectMany(f => f.PanelColors.Values).Distinct().Take(20);
+			foreach(var rgb in rgbs)
+			{
+				customEffectCommand.Palette.Add(ColorFormatConverter.ToPalette(rgb));
+			}
+		}
+
+		private string BuildPanelAnimData(int panelId)
+		{
+			//Example taken from docs. This method returns one of the panel rows
+			//(semicolons and newlines added for clarity only):
+			//numPanels; 
+			//panelId0; numFrames0; RGBWT01; RGBWT02; ... RGBWT0n(0);
+			//panelId1; numFrames1; RGBWT11; RGBWT12; ... RGBWT1n(1); ... ...
+			//panelIdN; numFramesN; RGBWTN1; RGBWTN2; ... RGBWTNn(N);
+			//RGB=color, W=0, Txx is transition time is tenths of a second
+
+			var sb = new StringBuilder();
+			uint? prevRgb = null;
+
+			var totalFrames = 0;
+			var sameColorFrameCount = 0;
+
+			foreach (var rgb in _customEffect.Frames.Select(f => f.PanelColors[panelId]))
+			{
+				if (prevRgb == null || rgb != prevRgb.Value)
+				{
+					if (prevRgb != null && sameColorFrameCount > 0)
+					{
+						sb.AppendFormat(" {0} {1} {2} 0 {3}",
+						(prevRgb >> 16) & 255,	// Get the value for red by shifting 2 bytes right
+						(prevRgb >> 8) & 255,	// Get the value for green by shifting one byte right
+						prevRgb & 255,			// Get the value for blue by taking the lowest byte
+						sameColorFrameCount * _transitionTime);
+
+						totalFrames++;
+					}
+
+					sb.AppendFormat(" {0} {1} {2} 0 {3}",
+						(rgb >> 16) & 255,
+						(rgb >> 8) & 255,
+						rgb & 255,
+						_transitionTime);
+
+					sameColorFrameCount = 0;
+					totalFrames++;
+				}
+				else
+				{
+					sameColorFrameCount++;
+				}
+
+				prevRgb = rgb;
+			}
+
+			//Prepend panelId numframes
+			return string.Format(" {0} {1}{2}", panelId, totalFrames, sb);
+		}
+
+	}
+}

Winleafs.Wpf/Api/Effects/CustomEffectsCollection.cs

@@ -22,7 +22,7 @@ public CustomEffectsCollection(Orchestrator orchestrator)
 
             var customColorEffects = UserSettings.Settings.CustomEffects;
 
-            if (customColorEffects != null && customColorEffects.Any())
+            if (customColorEffects != null && customColorEffects.Count > 0)
             {
                 foreach (var customColorEffect in customColorEffects)
                 {