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(50)).ConfigureAwait(false);
var currentlyPlayingObject = await this.Web.API.GetCurrentlyPlayingTrackAsync().ConfigureAwait(false);
if (currentlyPlayingObject?.Track == null || !currentlyPlayingObject.Track.IsValid())
{
return(false);
}
ISpotifyTrack newTrack = currentlyPlayingObject.Track;
if (!SpotifyTrack.Equal(this.CurrentTrack, newTrack))
{
ISpotifyTrack oldTrack = this.CurrentTrack;
this.CurrentTrack = newTrack;
await this.OnTrackChanged(oldTrack).ConfigureAwait(false);
}
await this.OnPlayStateChanged(currentlyPlayingObject.IsPlaying).ConfigureAwait(false);
return(true);
}
public SpotifyStateEventArgs(ISpotifyTrack currentTrack, bool playing, double trackTime, double volume)
{
this.CurrentTrack = currentTrack;
this.Playing = playing;
this.TrackTime = trackTime;
this.Volume = volume;
}
public CurrentlyPlayingObject(int progressMs, bool isPlaying, ISpotifyTrack track, SpotifyTrackType type)
{
this.ProgressMs = progressMs;
this.IsPlaying = isPlaying;
this.Track = track;
this.Type = type;
}
public JsonTrack(ISpotifyTrack track)
{
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;
}
}
public static bool Equal(ISpotifyTrack s1, ISpotifyTrack s2)
{
if (ReferenceEquals(s1, s2))
{
return(true);
}
if (s1 == null || s2 == null)
{
return(false);
}
return(s1.Equals((object)s2));
}
private async void SpotifyWindowTitleWatcher_TitleChanged(object sender, WindowTitleChangedEventArgs e)
{
// TODO: Refactor this method
try
{
if (logger.IsDebugEnabled)
{
logger.Debug($"Spotify's window title changed: \"{e.NewTitle}\". Fetching song info...");
}
if (!(Settings.Current.EnableSpotifyWebApi && this.IsWebApiRunning &&
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.
if (logger.IsDebugEnabled)
{
logger.Debug("Fetching song info using old method based on the title of Spotify's window...");
}
bool updateSong = true;
if (SpotifyWindow.PausedTitles.Contains(e.NewTitle, StringComparer.InvariantCulture))
{
await this.OnPlayStateChanged(false).ConfigureAwait(false);
updateSong = false;
}
else if (!this.IsPlaying)
{
await this.OnPlayStateChanged(true).ConfigureAwait(false);
}
if (updateSong)
{
ISpotifyTrack newSong = Song.FromSpotifyWindowTitle(e.NewTitle);
if (!SpotifyTrack.Equal(this.CurrentTrack, newSong))
{
ISpotifyTrack oldSong = this.CurrentTrack;
this.CurrentTrack = newSong;
await this.OnTrackChanged(oldSong).ConfigureAwait(false);
}
}
}
}
catch (Exception exception)
{
logger.Error($"Unhandled exception in {nameof(this.SpotifyWindowTitleWatcher_TitleChanged)}.", exception);
}
}
public bool Equals(ISpotifyTrack other)
{
if (other == null)
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return(this.Type == other.Type &&
string.Equals(this.Title, other.Title, StringComparison.InvariantCulture) &&
this.Length == other.Length);
}
private async Task OnTrackChanged(ISpotifyTrack previousTrack)
{
this.TrackChanged?.Invoke(this, new SpotifyTrackChangedEventArgs(previousTrack, this.CurrentTrack));
await this.Broadcaster.BroadcastCurrentTrack(this.CurrentTrack).ConfigureAwait(false);
}
public SpotifyTrackChangedEventArgs(ISpotifyTrack previousTrack, ISpotifyTrack newTrack)
{
this.PreviousTrack = previousTrack;
this.NewTrack = newTrack;
}
private async void SpotifyWindowTitleWatcher_TitleChanged(object sender, WindowTitleChangedEventArgs e)
{
// TODO: Refactor this method
try
{
if (logger.IsDebugEnabled)
{
logger.Debug($"Spotify's window title changed: \"{e.NewTitle}\". Fetching song info...");
}
bool shouldUpdateUsingWindowTitle = !(Settings.Current.EnableSpotifyWebApi && this.IsWebApiRunning);
this.apiTrackDelayedUpdateTimer?.Dispose();
bool tooFast = this.songChangesInTimespan >= 3;
if (!shouldUpdateUsingWindowTitle && tooFast)
{
logger.Debug($"Songs are being changed too fast ({this.songChangesInTimespan} times in {this.songChangeBuffer.TotalMilliseconds} ms)!");
this.apiTrackDelayedUpdateTimer = new Timer(async state =>
{
logger.Debug($"Executing delayed track update using WebAPI (\"{state}\")");
await this.UpdateTrackInfoUsingWebApi().ConfigureAwait(false);
}, e.NewTitle, this.songChangeBuffer, TimeSpan.FromMilliseconds(-1));
shouldUpdateUsingWindowTitle = true;
}
if (!shouldUpdateUsingWindowTitle)
{
shouldUpdateUsingWindowTitle = !await this.UpdateTrackInfoUsingWebApi().ConfigureAwait(false);
}
if (shouldUpdateUsingWindowTitle)
{
// 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.
if (logger.IsDebugEnabled)
{
logger.Debug("Fetching song info using old method based on the title of Spotify's window...");
}
bool updateSong = true;
if (SpotifyWindow.PausedTitles.Contains(e.NewTitle, StringComparer.InvariantCulture))
{
await this.OnPlayStateChanged(false).ConfigureAwait(false);
updateSong = false;
}
else if (!this.IsPlaying)
{
await this.OnPlayStateChanged(true).ConfigureAwait(false);
}
if (updateSong)
{
ISpotifyTrack newSong = Song.FromSpotifyWindowTitle(e.NewTitle);
if (!SpotifyTrack.Equal(this.CurrentTrack, newSong))
{
ISpotifyTrack oldSong = this.CurrentTrack;
this.CurrentTrack = newSong;
await this.OnTrackChanged(oldSong).ConfigureAwait(false);
}
}
}
this.songChangesInTimespan++;
if (DateTime.Now - this.lastSongChange > this.songChangeBuffer)
{
this.songChangesInTimespan = 0;
}
this.lastSongChange = DateTime.Now;
}
catch (Exception exception)
{
logger.Error($"Unhandled exception in {nameof(this.SpotifyWindowTitleWatcher_TitleChanged)}.", exception);
}
}
