public async Task <DequeueResult> DequeueAsync(IList <TrackViewModel> tracks)
{
DequeueResult dequeueResult = await this.queueManager.DequeueAsync(tracks);
if (dequeueResult.IsSuccess & dequeueResult.IsPlayingTrackDequeued)
{
if (dequeueResult.NextAvailableTrack != null)
{
await this.TryPlayAsync(dequeueResult.NextAvailableTrack);
}
else
{
this.Stop();
}
}
this.QueueChanged(this, new EventArgs());
this.ResetSaveQueuedTracksTimer(); // Save queued tracks to the database
return(dequeueResult);
}
public async Task <DequeueResult> DequeueAsync(IList <KeyValuePair <string, PlayableTrack> > tracks)
{
bool isSuccess = true;
var dequeuedTracks = new List <KeyValuePair <string, PlayableTrack> >();
int indexOfLastDeueuedTrack = 0;
bool isPlayingTrackDequeued = false;
await Task.Run(() =>
{
lock (this.queueLock)
{
foreach (var track in tracks)
{
try
{
if (this.queue.ContainsKey(track.Key))
{
// If the key is known, remove by key.
this.queue.Remove(track.Key);
dequeuedTracks.Add(track);
// If the key is known, indicate if the current track was dequeued by comparing the keys.
isPlayingTrackDequeued = isPlayingTrackDequeued || track.Key.Equals(this.currentTrack.Key);
}
else
{
// If the key is not known, get all queued tracks which have the same path.
var queuedTracksWithSamePath = this.queue.Select(t => t).Where(t => t.Value.SafePath.Equals(track.Value.SafePath)).ToList();
// Remove all queued track which have the same path
foreach (var queuedTrackWithSamePath in queuedTracksWithSamePath)
{
this.queue.Remove(queuedTrackWithSamePath.Key);
dequeuedTracks.Add(queuedTrackWithSamePath);
// If the key is not known, indicate if the current track was dequeued by comparing the paths.
isPlayingTrackDequeued = isPlayingTrackDequeued || queuedTrackWithSamePath.Value.Equals(this.currentTrack.Value);
}
}
}
catch (Exception ex)
{
isSuccess = false;
LogClient.Error("Error while removing queued track with path='{0}'. Exception: {1}", track.Value.Path, ex.Message);
}
}
foreach (var dequeuedTrack in dequeuedTracks)
{
try
{
int indexOfCurrentDequeuedTrack = this.playbackOrder.IndexOf(dequeuedTrack.Key);
if (indexOfLastDeueuedTrack == 0 | indexOfCurrentDequeuedTrack < indexOfLastDeueuedTrack)
{
indexOfLastDeueuedTrack = indexOfCurrentDequeuedTrack;
}
this.playbackOrder.Remove(dequeuedTrack.Key);
}
catch (Exception ex)
{
isSuccess = false;
LogClient.Error("Error while removing shuffled track with path='{0}'. Exception: {1}", dequeuedTrack.Value.Path, ex.Message);
}
}
}
});
var dequeueResult = new DequeueResult {
IsSuccess = isSuccess, DequeuedTracks = dequeuedTracks, IsPlayingTrackDequeued = isPlayingTrackDequeued
};
if (isSuccess && isPlayingTrackDequeued)
{
if (this.playbackOrder.Count == 0)
{
await this.ClearQueueAsync();
}
else if (this.playbackOrder.Count > indexOfLastDeueuedTrack)
{
dequeueResult.NextAvailableTrack =
new KeyValuePair <string, PlayableTrack>(this.playbackOrder[indexOfLastDeueuedTrack],
this.queue[this.playbackOrder[indexOfLastDeueuedTrack]]);
}
}
return(dequeueResult);
}
public async Task <DequeueResult> DequeueAsync(IList <TrackViewModel> tracks)
{
bool isSuccess = true;
bool isPlayingTrackDequeued = false;
IList <TrackViewModel> dequeuedTracks = new List <TrackViewModel>();
TrackViewModel nextAvailableTrack = null;
await Task.Run(() =>
{
lock (this.queueLock)
{
try
{
// First, get the tracks to dequeue and which are in the queue (normally it's all of them. But we're just making sure.)
IList <TrackViewModel> tracksToDequeue = this.queue.Where(x => tracks.Contains(x)).ToList();
// Then, remove from playbackOrder
foreach (TrackViewModel trackToDequeue in tracksToDequeue)
{
try
{
try
{
nextAvailableTrack = this.queue[this.playbackOrder[this.FindPlaybackOrderIndex(trackToDequeue) + 1]];
}
catch (Exception)
{
// Intended suppression
}
this.playbackOrder.Remove(this.FindPlaybackOrderIndex(trackToDequeue));
}
catch (Exception ex)
{
LogClient.Error($"Error while removing track with path='{trackToDequeue.Path}' from the playbackOrder. Exception: {ex.Message}");
throw;
}
}
// Finally, remove from queue
foreach (TrackViewModel trackToDequeue in tracksToDequeue)
{
try
{
this.queue.Remove(trackToDequeue);
isPlayingTrackDequeued = isPlayingTrackDequeued || trackToDequeue.Equals(this.currentTrack);
dequeuedTracks.Add(trackToDequeue);
}
catch (Exception ex)
{
LogClient.Error($"Error while removing track with path='{trackToDequeue.Path}' from the queue. Exception: {ex.Message}");
throw;
}
}
}
catch (Exception ex)
{
LogClient.Error($"Error while removing tracks from the queue. Queue will be cleared. Exception: {ex.Message}");
isSuccess = false;
}
}
});
if (!isSuccess)
{
LogClient.Warning($"Removing tracks from queue failed. Clearing queue.");
await this.ClearQueueAsync();
dequeuedTracks = new List <TrackViewModel>(tracks);
}
var dequeueResult = new DequeueResult
{
IsSuccess = isSuccess,
DequeuedTracks = dequeuedTracks,
NextAvailableTrack = nextAvailableTrack,
IsPlayingTrackDequeued = isPlayingTrackDequeued
};
return(dequeueResult);
}
