Replace ISong with ISpotifyTrack to handle different track types

Author: aleab

Toastify.Test/Toastify.Tests.csproj

@@ -58,7 +58,7 @@
     </Reference>
     <Reference Include="PresentationCore" />
     <Reference Include="SpotifyAPI.Web, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
-      <HintPath>..\packages\SpotifyAPI.Web.3.0.2\lib\net46\SpotifyAPI.Web.dll</HintPath>
+      <HintPath>..\packages\SpotifyAPI.Web.3.1.0\lib\net46\SpotifyAPI.Web.dll</HintPath>
     </Reference>
     <Reference Include="System" />
     <Reference Include="System.Windows" />

Toastify.Test/packages.config

@@ -6,5 +6,5 @@
   <package id="JetBrains.Annotations" version="11.1.0" targetFramework="net45" />
   <package id="Newtonsoft.Json" version="11.0.2" targetFramework="net45" />
   <package id="NUnit" version="3.10.1" targetFramework="net45" />
-  <package id="SpotifyAPI.Web" version="3.0.2" targetFramework="net472" />
+  <package id="SpotifyAPI.Web" version="3.1.0" targetFramework="net472" />
 </packages>

Toastify/Toastify.csproj

@@ -63,7 +63,7 @@
     <PackageReference Include="Microsoft.Packaging.Tools.Trimming" Version="1.1.0-preview1-26619-01" />
     <PackageReference Include="Newtonsoft.Json" Version="11.0.2" />
     <PackageReference Include="PowerArgs" Version="2.8.1" />
-    <PackageReference Include="SpotifyAPI.Web" Version="3.0.2" />
+    <PackageReference Include="SpotifyAPI.Web" Version="3.1.0" />
   </ItemGroup>
 
   <!-- Regular References -->

Toastify/src/Core/Broadcaster/JsonGreetingsObject.cs

@@ -9,8 +9,8 @@ public class JsonGreetingsObject
     {
         #region Public Properties
 
-        [JsonProperty("song")]
-        public JsonSong Song { get; set; }
+        [JsonProperty("track")]
+        public JsonTrack Track { get; set; }
 
         [JsonProperty("playing")]
         public bool Playing { get; set; }

Toastify/src/Core/Broadcaster/JsonSong.cs Toastify/src/Core/Broadcaster/JsonTrack.cs

@@ -2,36 +2,46 @@
 using System.Collections.Generic;
 using System.Linq;
 using Newtonsoft.Json;
+using ToastifyAPI.Core;
 using ToastifyAPI.Model.Interfaces;
 
 namespace Toastify.Core.Broadcaster
 {
     [Serializable]
     [JsonObject(MemberSerialization.OptIn)]
-    public class JsonSong
+    public class JsonTrack
     {
         #region Public Properties
 
+        [JsonProperty("type")]
+        public SpotifyTrackType Type { get; }
+
         [JsonProperty("title")]
         public string Title { get; }
 
+        [JsonProperty("length")]
+        public int Length { get; }
+
         [JsonProperty("artists")]
         public List<string> Artists { get; }
 
         [JsonProperty("album")]
         public string Album { get; }
 
-        [JsonProperty("length")]
-        public int Length { get; }
-
         #endregion
 
-        public JsonSong(ISong song)
+        public JsonTrack(ISpotifyTrack track)
         {
-            this.Title = song?.Title;
-            this.Artists = song?.Artists.ToList();
-            this.Album = song?.Album;
-            this.Length = song?.Length ?? -1;
+            this.Type = track?.Type ?? SpotifyTrackType.Unknown;
+            this.Title = track?.Title;
+            this.Length = track?.Length ?? 0;
+
+            if (track?.Type == SpotifyTrackType.Song)
+            {
+                ISong song = track as ISong;
+                this.Artists = song?.Artists.ToList();
+                this.Album = song?.Album;
+            }
         }
     }
 }

Toastify/src/Core/Broadcaster/ToastifyBroadcaster.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Globalization;
 using System.Net;
 using System.Net.Sockets;
 using System.Net.WebSockets;
@@ -19,6 +20,12 @@ public class ToastifyBroadcaster : IToastifyBroadcaster, IDisposable
     {
         private static readonly ILog logger = LogManager.GetLogger(typeof(ToastifyBroadcaster));
 
+        #region Static Fields and Properties
+
+        public static JsonSerializerSettings JsonSerializerSettings { get; }
+
+        #endregion
+
         private ClientWebSocket socket;
         private KestrelWebSocketHost<ToastifyWebSocketHostStartup> webHost;
         private Thread receiveMessageThread;
@@ -40,6 +47,32 @@ public class ToastifyBroadcaster : IToastifyBroadcaster, IDisposable
 
         #endregion
 
+        static ToastifyBroadcaster()
+        {
+            JsonSerializerSettings = new JsonSerializerSettings
+            {
+                StringEscapeHandling = StringEscapeHandling.Default,
+                FloatParseHandling = FloatParseHandling.Decimal,
+                FloatFormatHandling = FloatFormatHandling.String,
+                DateParseHandling = DateParseHandling.DateTime,
+                DateTimeZoneHandling = DateTimeZoneHandling.Local,
+                DateFormatHandling = DateFormatHandling.IsoDateFormat,
+                Formatting = Formatting.None,
+                MaxDepth = null,
+                Culture = CultureInfo.InvariantCulture,
+                ConstructorHandling = ConstructorHandling.Default,
+                TypeNameAssemblyFormatHandling = TypeNameAssemblyFormatHandling.Simple,
+                MetadataPropertyHandling = MetadataPropertyHandling.Default,
+                TypeNameHandling = TypeNameHandling.None,
+                PreserveReferencesHandling = PreserveReferencesHandling.None,
+                DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate,
+                NullValueHandling = NullValueHandling.Ignore,
+                ObjectCreationHandling = ObjectCreationHandling.Auto,
+                MissingMemberHandling = MissingMemberHandling.Ignore,
+                ReferenceLoopHandling = ReferenceLoopHandling.Ignore
+            };
+        }
+
         public ToastifyBroadcaster() : this(41348)
         {
         }
@@ -444,10 +477,10 @@ private async Task Broadcast(params string[] args)
             await this.SendCommand("BROADCAST", args).ConfigureAwait(false);
         }
 
-        public async Task BroadcastCurrentSong<T>(T song) where T : ISong
+        public async Task BroadcastCurrentTrack<T>(T track) where T : ISpotifyTrack
         {
-            string songJson = song != null ? JsonConvert.SerializeObject(new JsonSong(song)) : "null";
-            await this.Broadcast("CURRENT-SONG", songJson).ConfigureAwait(false);
+            string trackJson = track != null ? JsonConvert.SerializeObject(new JsonTrack(track), JsonSerializerSettings) : "null";
+            await this.Broadcast("CURRENT-TRACK", trackJson).ConfigureAwait(false);
         }
 
         public async Task BroadcastPlayState(bool playing)

Toastify/src/Core/Broadcaster/ToastifyWebSocketHostStartup.cs

@@ -75,7 +75,7 @@ private async Task HandleInternal(string message, WebSocket webSocket)
                     string cmd = match.Groups[1].Value;
                     switch (match.Groups[1].Value)
                     {
-                        case "CURRENT-SONG":
+                        case "CURRENT-TRACK":
                             foreach (var client in this.clients)
                             {
                                 await RedirectTo($"{cmd} {match.Groups[2].Value}", client).ConfigureAwait(false);
@@ -191,7 +191,7 @@ protected override void OnWebSocketConnected(HttpContext context, WebSocket webS
                         {
                             JsonGreetingsObject greetings = new JsonGreetingsObject
                             {
-                                Song = new JsonSong(Spotify.Instance.CurrentSong),
+                                Track = new JsonTrack(Spotify.Instance.CurrentTrack),
                                 Playing = Spotify.Instance.IsPlaying
                             };
                             await RedirectTo($"HELLO {JsonConvert.SerializeObject(greetings)}", webSocket).ConfigureAwait(false);

Toastify/src/Core/Spotify.cs

@@ -62,7 +62,7 @@ public bool IsRunning
             get { return this.spotifyWindow?.IsValid ?? false; }
         }
 
-        public ISong CurrentSong { get; private set; }
+        public ISpotifyTrack CurrentTrack { get; private set; }
 
         public bool IsPlaying { get; private set; }
 
@@ -80,7 +80,7 @@ public bool IsRunning
 
         public event EventHandler<SpotifyStateEventArgs> Connected;
 
-        public event EventHandler<SpotifyTrackChangedEventArgs> SongChanged;
+        public event EventHandler<SpotifyTrackChangedEventArgs> TrackChanged;
 
         public event EventHandler<SpotifyPlayStateChangedEventArgs> PlayStateChanged;
 
@@ -555,23 +555,23 @@ private void BeginInitializeWebAPI()
                 logger.Debug("Begin Spotify WebAPI initialization");
         }
 
-        private async Task<bool> UpdateSongInfoUsingWebApi()
+        private async Task<bool> UpdateTrackInfoUsingWebApi()
         {
             if (this.Web?.API == null)
                 return false;
 
             // Pre-emptively waiting a little bit to let the remote Spotify server update its own information
-            await Task.Delay(TimeSpan.FromMilliseconds(25)).ConfigureAwait(false);
+            await Task.Delay(TimeSpan.FromMilliseconds(50)).ConfigureAwait(false);
             var currentlyPlayingObject = await this.Web.API.GetCurrentlyPlayingTrackAsync().ConfigureAwait(false);
             if (currentlyPlayingObject?.Track == null || !currentlyPlayingObject.Track.IsValid())
                 return false;
 
-            ISong newSong = currentlyPlayingObject.Track;
-            if (newSong != null && !Song.Equal(this.CurrentSong, newSong))
+            ISpotifyTrack newTrack = currentlyPlayingObject.Track;
+            if (!SpotifyTrack.Equal(this.CurrentTrack, newTrack))
             {
-                ISong oldSong = this.CurrentSong;
-                this.CurrentSong = newSong;
-                await this.OnSongChanged(oldSong).ConfigureAwait(false);
+                ISpotifyTrack oldTrack = this.CurrentTrack;
+                this.CurrentTrack = newTrack;
+                await this.OnTrackChanged(oldTrack).ConfigureAwait(false);
             }
 
             await this.OnPlayStateChanged(currentlyPlayingObject.IsPlaying).ConfigureAwait(false);
@@ -680,12 +680,12 @@ private async void OnWebAPIInitializationSucceeded()
             var currentlyPlayingObject = await this.Web.API.GetCurrentlyPlayingTrackAsync().ConfigureAwait(false);
             if (currentlyPlayingObject?.Track != null && currentlyPlayingObject.Track.IsValid())
             {
-                this.CurrentSong = currentlyPlayingObject.Track;
+                this.CurrentTrack = currentlyPlayingObject.Track;
                 this.IsPlaying = currentlyPlayingObject.IsPlaying;
             }
 
             this.IsWebApiRunning = true;
-            this.WebAPIInitializationSucceeded?.Invoke(this, new SpotifyStateEventArgs(this.CurrentSong, this.IsPlaying, this.CurrentSong?.Length ?? 0.0, 1.0));
+            this.WebAPIInitializationSucceeded?.Invoke(this, new SpotifyStateEventArgs(this.CurrentTrack, this.IsPlaying, this.CurrentTrack?.Length ?? 0.0, 1.0));
         }
 
         private void OnWebAPIInitializationFailed(SpotifyWebAPIInitializationFailedReason reason)
@@ -708,7 +708,7 @@ private async Task OnSpotifyConnected(SpotifyStateEventArgs e)
             {
                 StringBuilder sb = new StringBuilder();
                 sb.Append($"Spotify Connected. Status = {{{Environment.NewLine}")
-                  .Append($"   CurrentSong: {(e.CurrentSong != null ? $"\"{e.CurrentSong}\"" : "null")},{Environment.NewLine}")
+                  .Append($"   CurrentSong: {(e.CurrentTrack != null ? $"\"{e.CurrentTrack}\"" : "null")},{Environment.NewLine}")
                   .Append($"   Playing: {e.Playing},{Environment.NewLine}")
                   .Append($"   TrackTime: {e.TrackTime},{Environment.NewLine}")
                   .Append($"   Volume: {e.Volume}{Environment.NewLine}")
@@ -717,7 +717,7 @@ private async Task OnSpotifyConnected(SpotifyStateEventArgs e)
             }
 
             this.IsPlaying = e.Playing;
-            this.CurrentSong = e.CurrentSong;
+            this.CurrentTrack = e.CurrentTrack;
 
             this.Connected?.Invoke(this, e);
 
@@ -732,14 +732,14 @@ private async Task OnSpotifyConnected(SpotifyStateEventArgs e)
             {
                 await this.Broadcaster.StartAsync().ConfigureAwait(false);
                 await this.Broadcaster.BroadcastPlayState(e.Playing).ConfigureAwait(false);
-                await this.Broadcaster.BroadcastCurrentSong(e.CurrentSong).ConfigureAwait(false);
+                await this.Broadcaster.BroadcastCurrentTrack(e.CurrentTrack).ConfigureAwait(false);
             }
         }
 
-        private async Task OnSongChanged(ISong previousSong)
+        private async Task OnTrackChanged(ISpotifyTrack previousTrack)
         {
-            this.SongChanged?.Invoke(this, new SpotifyTrackChangedEventArgs(previousSong, this.CurrentSong));
-            await this.Broadcaster.BroadcastCurrentSong(this.CurrentSong).ConfigureAwait(false);
+            this.TrackChanged?.Invoke(this, new SpotifyTrackChangedEventArgs(previousTrack, this.CurrentTrack));
+            await this.Broadcaster.BroadcastCurrentTrack(this.CurrentTrack).ConfigureAwait(false);
         }
 
         private async Task OnPlayStateChanged(bool playing)
@@ -853,7 +853,7 @@ private async void SpotifyWindowTitleWatcher_TitleChanged(object sender, WindowT
                     logger.Debug($"Spotify's window title changed: \"{e.NewTitle}\". Fetching song info...");
 
                 if (!(Settings.Current.EnableSpotifyWebApi && this.IsWebApiRunning &&
-                      await this.UpdateSongInfoUsingWebApi().ConfigureAwait(false)))
+                      await this.UpdateTrackInfoUsingWebApi().ConfigureAwait(false)))
                 {
                     // If the WebAPIs are disabled or they weren't able to retrieve the song info, fallback to
                     // the old method based on the title of Spotify's window.
@@ -872,12 +872,12 @@ await this.UpdateSongInfoUsingWebApi().ConfigureAwait(false)))
 
                     if (updateSong)
                     {
-                        ISong newSong = Song.FromSpotifyWindowTitle(e.NewTitle);
-                        if (!Song.Equal(this.CurrentSong, newSong))
+                        ISpotifyTrack newSong = Song.FromSpotifyWindowTitle(e.NewTitle);
+                        if (!SpotifyTrack.Equal(this.CurrentTrack, newSong))
                         {
-                            ISong oldSong = this.CurrentSong;
-                            this.CurrentSong = newSong;
-                            await this.OnSongChanged(oldSong).ConfigureAwait(false);
+                            ISpotifyTrack oldSong = this.CurrentTrack;
+                            this.CurrentTrack = newSong;
+                            await this.OnTrackChanged(oldSong).ConfigureAwait(false);
                         }
                     }
                 }

Toastify/src/Events/SpotifyStateEventArgs.cs

@@ -8,16 +8,16 @@ public class SpotifyStateEventArgs : EventArgs
     {
         #region Public Properties
 
-        public ISong CurrentSong { get; }
+        public ISpotifyTrack CurrentTrack { get; }
         public bool Playing { get; }
         public double TrackTime { get; }
         public double Volume { get; }
 
         #endregion
 
-        public SpotifyStateEventArgs(ISong currentSong, bool playing, double trackTime, double volume)
+        public SpotifyStateEventArgs(ISpotifyTrack currentTrack, bool playing, double trackTime, double volume)
         {
-            this.CurrentSong = currentSong;
+            this.CurrentTrack = currentTrack;
             this.Playing = playing;
             this.TrackTime = trackTime;
             this.Volume = volume;

Toastify/src/Events/SpotifyTrackChangedEventArgs.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using ToastifyAPI.Model.Interfaces;
 
 namespace Toastify.Events
@@ -7,15 +7,15 @@ public class SpotifyTrackChangedEventArgs : EventArgs
     {
         #region Public Properties
 
-        public ISong PreviousSong { get; }
-        public ISong NewSong { get; }
+        public ISpotifyTrack PreviousTrack { get; }
+        public ISpotifyTrack NewTrack { get; }
 
         #endregion
 
-        public SpotifyTrackChangedEventArgs(ISong previousSong, ISong newSong)
+        public SpotifyTrackChangedEventArgs(ISpotifyTrack previousTrack, ISpotifyTrack newTrack)
         {
-            this.PreviousSong = previousSong;
-            this.NewSong = newSong;
+            this.PreviousTrack = previousTrack;
+            this.NewTrack = newTrack;
         }
     }
 }