public async Task <DequeueResult> DequeueAsync(IList <PlayableTrack> tracks) { IList <KeyValuePair <string, PlayableTrack> > trackPairs = new List <KeyValuePair <string, PlayableTrack> >(); await Task.Run(() => { foreach (PlayableTrack track in tracks) { // New Guids are created here, they will never be found in the queue. // QueueManager will dequeue all tracks which have a matching SafePath. trackPairs.Add(new KeyValuePair <string, PlayableTrack>(Guid.NewGuid().ToString(), track)); } }); DequeueResult dequeueResult = await this.queueManager.DequeueAsync(trackPairs); if (dequeueResult.IsSuccess & dequeueResult.IsPlayingTrackDequeued) { if (!dequeueResult.NextAvailableTrack.Equals(default(KeyValuePair <string, PlayableTrack>))) { 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) { DequeueResult dequeueResult = await this.queueManager.DequeueAsync(tracks); if (dequeueResult.IsSuccess & dequeueResult.IsPlayingTrackDequeued) { if (!dequeueResult.NextAvailableTrack.Equals(default(KeyValuePair <string, PlayableTrack>))) { 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 (KeyValuePair <string, PlayableTrack> 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 = track.Key.Equals(this.currentTrack.Key); } else { // If the key is not known, get all queued tracks which have the same path. List <KeyValuePair <string, PlayableTrack> > 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 (KeyValuePair <string, PlayableTrack> 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 = 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 (KeyValuePair <string, PlayableTrack> 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 & this.playbackOrder.Count > indexOfLastDeueuedTrack) { dequeueResult.NextAvailableTrack = new KeyValuePair <string, PlayableTrack>(this.playbackOrder[indexOfLastDeueuedTrack], this.queue[this.playbackOrder[indexOfLastDeueuedTrack]]); } return(dequeueResult); }
public async Task <DequeueResult> Dequeue(IList <TrackInfo> selectedTracks) { bool isSuccess = true; var removedQueuedTracks = new List <TrackInfo>(); var removedShuffledTracks = new List <TrackInfo>(); int smallestIndex = 0; bool playNext = false; await Task.Run(() => { lock (this.queueSyncObject) { foreach (TrackInfo ti in selectedTracks) { try { // Remove from this.queuedTracks. The index doesn't matter. if (this.queuedTracks.Contains(ti)) { this.queuedTracks.Remove(ti); removedQueuedTracks.Add(ti); } } catch (Exception ex) { isSuccess = false; LogClient.Instance.Logger.Error("Error while removing queued track with path='{0}'. Exception: {1}", ti.Path, ex.Message); } } foreach (TrackInfo ti in removedQueuedTracks) { // Remove from this.shuffledTracks. The index does matter, // as we might have to play the next remaining Track. try { int index = this.shuffledTracks.IndexOf(ti); if (index >= 0) { if (this.shuffledTracks[index].Equals(this.playingTrack)) { playNext = true; } TrackInfo removedShuffledTrack = this.shuffledTracks[index]; this.shuffledTracks.RemoveAt(index); removedShuffledTracks.Add(removedShuffledTrack); if (smallestIndex == 0 || (index < smallestIndex)) { smallestIndex = index; } } } catch (Exception ex) { isSuccess = false; LogClient.Instance.Logger.Error("Error while removing shuffled track with path='{0}'. Exception: {1}", ti.Path, ex.Message); } } } }); if (playNext & isSuccess) { if (this.shuffledTracks.Count > smallestIndex) { await this.TryPlayAsync(this.shuffledTracks[smallestIndex]); } else { this.Stop(); } } var dequeueResult = new DequeueResult { IsSuccess = isSuccess, DequeuedTracks = removedShuffledTracks }; this.ShuffledTracksChanged(this, new EventArgs()); this.ResetSaveQueuedTracksTimer(); // Save queued tracks to the database return(dequeueResult); }