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