public async Task DeleteFromQueueAsync(QueueSong songToRemove)
{
QueueSong previousModel;
if (songToRemove == null)
{
return;
}
if (_lookupMap.TryGetValue(songToRemove.PrevId, out previousModel))
{
previousModel.NextId = songToRemove.NextId;
await _bgSqlService.UpdateItemAsync(previousModel);
}
if (_lookupMap.TryGetValue(songToRemove.ShufflePrevId, out previousModel))
{
previousModel.ShuffleNextId = songToRemove.ShuffleNextId;
await _bgSqlService.UpdateItemAsync(previousModel);
}
QueueSong nextModel;
if (_lookupMap.TryGetValue(songToRemove.NextId, out nextModel))
{
nextModel.PrevId = songToRemove.PrevId;
await _bgSqlService.UpdateItemAsync(nextModel);
}
if (_lookupMap.TryGetValue(songToRemove.ShuffleNextId, out nextModel))
{
nextModel.ShufflePrevId = songToRemove.ShufflePrevId;
await _bgSqlService.UpdateItemAsync(nextModel);
}
await _dispatcher.RunAsync(
() =>
{
PlaybackQueue.Remove(songToRemove);
ShufflePlaybackQueue.Remove(songToRemove);
});
_lookupMap.TryRemove(songToRemove.Id, out songToRemove);
// Delete from database
await _bgSqlService.DeleteItemAsync(songToRemove);
}
public async Task ClearQueueAsync()
{
if (PlaybackQueue.Count == 0)
{
return;
}
await _bgSqlService.DeleteTableAsync <QueueSong>();
_lookupMap.Clear();
await _dispatcher.RunAsync(
() =>
{
PlaybackQueue.Clear();
ShufflePlaybackQueue.Clear();
});
}
public async Task ShuffleCurrentQueueAsync()
{
var newShuffle = await Task.Factory.StartNew(() => PlaybackQueue.ToList().Shuffle()).ConfigureAwait(false);
if (newShuffle.Count > 0)
{
await _dispatcher.RunAsync(() => ShufflePlaybackQueue.SwitchTo(newShuffle)).ConfigureAwait(false);
for (var i = 0; i < newShuffle.Count; i++)
{
var queueSong = newShuffle[i];
queueSong.ShufflePrevId = i == 0 ? 0 : newShuffle[i - 1].Id;
if (i + 1 < newShuffle.Count)
{
queueSong.ShuffleNextId = newShuffle[i + 1].Id;
}
await _bgSqlService.UpdateItemAsync(queueSong).ConfigureAwait(false);
}
}
}
private void LoadQueue(List <Song> songs)
{
var queue = _bgSqlService.SelectAll <QueueSong>();
QueueSong head = null;
QueueSong shuffleHead = null;
foreach (var queueSong in queue)
{
queueSong.Song = songs.FirstOrDefault(p => p.Id == queueSong.SongId);
_lookupMap.TryAdd(queueSong.Id, queueSong);
if (queueSong.ShufflePrevId == 0)
{
shuffleHead = queueSong;
}
if (queueSong.PrevId == 0)
{
head = queueSong;
}
}
if (head != null)
{
for (var i = 0; i < queue.Count; i++)
{
if (_dispatcher != null)
{
_dispatcher.RunAsync(() => PlaybackQueue.Add(head)).Wait();
}
else
{
PlaybackQueue.Add(head);
}
QueueSong value;
if (head.NextId != 0 && _lookupMap.TryGetValue(head.NextId, out value))
{
head = value;
}
else
{
break;
}
}
}
if (shuffleHead != null)
{
for (var i = 0; i < queue.Count; i++)
{
if (_dispatcher != null)
{
_dispatcher.RunAsync(() => ShufflePlaybackQueue.Add(shuffleHead)).Wait();
}
else
{
ShufflePlaybackQueue.Add(shuffleHead);
}
QueueSong value;
if (shuffleHead.ShuffleNextId != 0 && _lookupMap.TryGetValue(shuffleHead.ShuffleNextId, out value))
{
shuffleHead = value;
}
else
{
break;
}
}
}
}
public async Task <QueueSong> AddToQueueAsync(Song song, QueueSong position = null, bool shuffleInsert = true)
{
if (song == null)
{
return(null);
}
var rnd = new Random(DateTime.Now.Millisecond);
QueueSong prev = null;
QueueSong shufflePrev = null;
QueueSong next = null;
QueueSong shuffleNext = null;
var shuffleIndex = -1;
var normalIndex = -1;
if (position != null)
{
shuffleIndex = ShufflePlaybackQueue.IndexOf(position) + 1;
normalIndex = PlaybackQueue.IndexOf(position) + 1;
}
var insert = normalIndex > -1 && normalIndex < PlaybackQueue.Count;
var insertShuffle = shuffleIndex > -1 && shuffleInsert;
var shuffleLastAdd = shuffleIndex == ShufflePlaybackQueue.Count;
if (insert)
{
next = PlaybackQueue.ElementAtOrDefault(normalIndex);
if (next != null)
{
_lookupMap.TryGetValue(next.PrevId, out prev);
}
}
else
{
prev = PlaybackQueue.LastOrDefault();
}
if (insertShuffle)
{
if (shuffleLastAdd)
{
shufflePrev = ShufflePlaybackQueue.ElementAtOrDefault(ShufflePlaybackQueue.Count - 1);
}
else
{
shuffleNext = ShufflePlaybackQueue.ElementAtOrDefault(shuffleIndex);
if (shuffleNext != null)
{
_lookupMap.TryGetValue(shuffleNext.ShufflePrevId, out shufflePrev);
}
}
}
else
{
if (ShufflePlaybackQueue.Count > 1)
{
shuffleIndex = rnd.Next(1, ShufflePlaybackQueue.Count - 1);
shuffleNext = ShufflePlaybackQueue.ElementAt(shuffleIndex);
_lookupMap.TryGetValue(shuffleNext.ShufflePrevId, out shufflePrev);
}
else
{
shuffleLastAdd = true;
shufflePrev = prev;
}
}
// Create the new queue entry
var newQueue = new QueueSong
{
SongId = song.Id,
NextId = next == null ? 0 : next.Id,
PrevId = prev == null ? 0 : prev.Id,
ShuffleNextId = shuffleNext == null ? 0 : shuffleNext.Id,
ShufflePrevId = shufflePrev == null ? 0 : shufflePrev.Id,
Song = song
};
// Add it to the database
await _bgSqlService.InsertAsync(newQueue).ConfigureAwait(false);
if (next != null)
{
// Update the prev id of the queue that was replaced
next.PrevId = newQueue.Id;
await _bgSqlService.UpdateItemAsync(next).ConfigureAwait(false);
}
if (prev != null)
{
// Update the next id of the previous tail
prev.NextId = newQueue.Id;
await _bgSqlService.UpdateItemAsync(prev).ConfigureAwait(false);
}
if (shuffleNext != null)
{
shuffleNext.ShufflePrevId = newQueue.Id;
await _bgSqlService.UpdateItemAsync(shuffleNext).ConfigureAwait(false);
}
if (shufflePrev != null)
{
shufflePrev.ShuffleNextId = newQueue.Id;
await _bgSqlService.UpdateItemAsync(shufflePrev).ConfigureAwait(false);
}
// Add the new queue entry to the collection and map
await _dispatcher.RunAsync(
() =>
{
if (insert)
{
try
{
PlaybackQueue.Insert(normalIndex, newQueue);
}
catch (ArgumentOutOfRangeException)
{
PlaybackQueue.Add(newQueue);
}
}
else
{
PlaybackQueue.Add(newQueue);
}
if (shuffleLastAdd || !shuffleInsert)
{
ShufflePlaybackQueue.Add(newQueue);
}
else
{
try
{
ShufflePlaybackQueue.Insert(shuffleIndex, newQueue);
}
catch (ArgumentOutOfRangeException)
{
ShufflePlaybackQueue.Add(newQueue);
}
}
}).ConfigureAwait(false);
_lookupMap.TryAdd(newQueue.Id, newQueue);
return(newQueue);
}