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); }