/// <summary>
/// Add a list of Albums to a specified playlist
/// </summary>
/// <param name="albumsToAdd"></param>
/// <param name="playlist"></param>
public static void AddAlbumsToPlaylist(IEnumerable <Album> albumsToAdd, AlbumPlaylist playlist)
{
playlist.AddAlbums(albumsToAdd);
// Report the change
DataReporter?.PlaylistUpdated(playlist);
}
/// <summary>
/// Add the songs from the playlist to the Now Playing list
/// If this set is replacing the current contents (clearFirst == true ) then clear the Now Playimng list
/// first.
/// If a resume has been selected and the current contents are being replaced then add all of the
/// playlist's songs but set the current song to the resume point. If resume has been selected and the playlist is
/// being added to then only add the playlist songs from its resume point. Don't change the resume point in the source playlist.
/// If resume has not been selected then add all the playlist's contents and reset the playlist's restore point
/// </summary>
/// <param name="playlistToAdd"></param>
/// <param name="clearFirst"></param>
/// <param name="resume"></param>
public static void AddPlaylistToNowPlayingList(Playlist playlistToAdd, bool clearFirst, bool resume)
{
// Should the Now Playing playlist be cleared first
if (clearFirst == true)
{
ClearNowPlayingList();
}
// Assume we're going to play a new list from the start
int newCurrentIndex = 0;
if (resume == true)
{
if (clearFirst == true)
{
NowPlayingViewModel.NowPlayingPlaylist.AddSongs(playlistToAdd.GetSongsForPlayback(false));
newCurrentIndex = playlistToAdd.InProgressIndex;
}
else
{
NowPlayingViewModel.NowPlayingPlaylist.AddSongs(playlistToAdd.GetSongsForPlayback(true));
}
}
else
{
NowPlayingViewModel.NowPlayingPlaylist.AddSongs(ApplyShuffle(playlistToAdd.GetSongsForPlayback(false)));
playlistToAdd.SongIndex = 0;
}
// If the Now Playing list was cleared then play the specified song
SetStartingPointForNewList(clearFirst, newCurrentIndex);
// Report change to UI
DataReporter?.DataAvailable();
}
/// <summary>
/// Add a list of Songs to a specified playlist
/// </summary>
/// <param name="songsToAdd"></param>
/// <param name="playlist"></param>
public static void AddSongsToPlaylist(IEnumerable <Song> songsToAdd, SongPlaylist playlist)
{
playlist.AddSongs(songsToAdd);
// Report the change
DataReporter?.PlaylistUpdated(playlist);
}
/// <summary>
/// Called when a AlbumPlayedStateChangedMessage had been received.
/// If the album is in the library being displayed then refresh the display
/// </summary>
/// <param name="message"></param>
private static void AlbumChanged(Album changedAlbum)
{
// Only process this album if it is in the same library as is being displayed
// It may be in another library if this is being called as part of a library synchronisation process
if (changedAlbum.LibraryId == ArtistsViewModel.LibraryId)
{
DataReporter?.DataAvailable();
}
}
/// <summary>
/// Delete the specified SongPlaylistItem items from its parent playlist
/// </summary>
/// <param name="thePlaylist"></param>
/// <param name="items"></param>
public static void DeletePlaylistItems(Playlist thePlaylist, IEnumerable <PlaylistItem> items)
{
// Delete the items from the playlist
thePlaylist.DeletePlaylistItems(items);
// Adjust the track numbers
thePlaylist.AdjustTrackNumbers();
// Report the change
DataReporter?.PlaylistUpdated(thePlaylist);
}
/// <summary>
/// Called when a AlbumPlayedStateChangedMessage had been received.
/// If this album is being displayed then inform the adapter of the data change
/// </summary>
/// <param name="changedAlbum"></param>
private static void AlbumChanged(Album changedAlbum)
{
// Only process this if this album is in the library being displayed
if (changedAlbum.LibraryId == AlbumsViewModel.LibraryId)
{
// Is this album being displayed
if (AlbumsViewModel.Albums.Any(album => album.Id == changedAlbum.Id) == true)
{
DataReporter?.DataAvailable();
}
}
}
/// <summary>
/// Sort the Artists according to the currently selected sort order
/// </summary>
public static void SortArtists() => Task.Run(() =>
{
// Clear the indexing collections (in case they are not used in the new sort order)
ArtistsViewModel.FastScrollSections = null;
ArtistsViewModel.FastScrollSectionLookup = null;
switch (ArtistsViewModel.BaseModel.SortSelector.CurrentSortOrder)
{
case SortSelector.SortOrder.alphaDescending:
case SortSelector.SortOrder.alphaAscending:
{
if (ArtistsViewModel.BaseModel.SortSelector.CurrentSortOrder == SortSelector.SortOrder.alphaAscending)
{
ArtistsViewModel.Artists.Sort((a, b) => a.Name.RemoveThe().CompareTo(b.Name.RemoveThe()));
}
else
{
ArtistsViewModel.Artists.Sort((a, b) => b.Name.RemoveThe().CompareTo(a.Name.RemoveThe()));
}
// Prepare the combined Artist/ArtistAlbum list - this has to be done after the Artists have been sorted but before the scroll indexing
PrepareCombinedList();
// Generate the fast scroll data for alpha sorting
GenerateIndex((artist) => artist.Name.RemoveThe().Substring(0, 1).ToUpper());
break;
}
case SortSelector.SortOrder.idAscending:
case SortSelector.SortOrder.idDescending:
{
if (ArtistsViewModel.BaseModel.SortSelector.CurrentSortOrder == SortSelector.SortOrder.idAscending)
{
ArtistsViewModel.Artists.Sort((a, b) => a.Id.CompareTo(b.Id));
}
else
{
ArtistsViewModel.Artists.Sort((a, b) => b.Id.CompareTo(a.Id));
}
// Prepare the combined Artist/ArtistAlbum list - this has to be done after the Artists have been sorted.
// No fast scroll indexing is required for Id sort order
PrepareCombinedList();
break;
}
}
// Publish the data
DataReporter?.DataAvailable();
});
/// <summary>
/// Called when the SongPlaylist data is available to be displayed, or needs to be refreshed
/// </summary>
private static void StorageDataAvailable()
{
// Save the libray being used locally to detect changes
NowPlayingViewModel.LibraryId = ConnectionDetailsModel.LibraryId;
// Get the NowPlaying playlist.
NowPlayingViewModel.NowPlayingPlaylist = ( SongPlaylist )Playlists.GetNowPlayingPlaylist(NowPlayingViewModel.LibraryId);
// Let the playback manager know the current song but don't play it yet
NowPlayingViewModel.CurrentSongIndex = Playlists.CurrentSongIndex;
new PlaySongMessage()
{
SongToPlay = NowPlayingViewModel.CurrentSong, DontPlay = true
}.Send();
DataReporter?.DataAvailable();
}
/// <summary>
/// Add a list of Songs to the Now Playing list
/// </summary>
/// <param name="songsToAdd"></param>
/// <param name="clearFirst"></param>
public static void AddSongsToNowPlayingList(IEnumerable <Song> songsToAdd, bool clearFirst)
{
// Should the Now Playing playlist be cleared first
if (clearFirst == true)
{
ClearNowPlayingList();
}
// Add the songs to the playlist. Shuffled if necessary
NowPlayingViewModel.NowPlayingPlaylist.AddSongs(ApplyShuffle(songsToAdd.ToList()));
// If the Now Playing list was cleared then play the first song
SetStartingPointForNewList(clearFirst, 0);
// Report change to UI
DataReporter?.DataAvailable();
}
/// <summary>
/// Move the selected items up or down the list
/// </summary>
/// <param name="items"></param>
/// <param name="moveUp"></param>
private static void MoveItems(IEnumerable <PlaylistItem> items, bool moveUp)
{
// Record the currently selected song so its track number can be checked after the move
PlaylistItem currentPlaylistItem = (NowPlayingViewModel.CurrentSongIndex == -1) ? null
: NowPlayingViewModel.NowPlayingPlaylist.PlaylistItems[NowPlayingViewModel.CurrentSongIndex];
if (moveUp == true)
{
NowPlayingViewModel.NowPlayingPlaylist.MoveItemsUp(items);
}
else
{
NowPlayingViewModel.NowPlayingPlaylist.MoveItemsDown(items);
}
// Now adjust the index of the selected song
AdjustSelectedSongIndex(currentPlaylistItem);
// Report that the playlist has been updated - don't use NowPlayingDataAvailable as that will clear the selections
DataReporter?.PlaylistUpdated();
}
/// <summary>
/// Called during startup, or library change, when the storage data is available
/// </summary>
/// <param name="message"></param>
private static async void StorageDataAvailable()
{
// Save the libray being used locally to detect changes
PlaylistsViewModel.LibraryId = ConnectionDetailsModel.LibraryId;
// Get the Playlists and playlist names. Make sure a copy of the list is used as we're going to sort it
PlaylistsViewModel.Playlists = Playlists.GetPlaylistsForLibrary(PlaylistsViewModel.LibraryId).ToList();
PlaylistsViewModel.PlaylistNames = PlaylistsViewModel.Playlists.Select(i => i.Name).ToList();
// To generate the data to be displayed the Playlists need to be sorted. Not a simple sort of course, but the SongPlaylists followed by the
// AlbumPlaylists
await Task.Run(() =>
{
PlaylistsViewModel.AlbumPlaylists.Clear();
PlaylistsViewModel.SongPlaylists.Clear();
foreach (Playlist playlist in PlaylistsViewModel.Playlists)
{
if (playlist is SongPlaylist songPlaylist)
{
PlaylistsViewModel.SongPlaylists.Add(songPlaylist);
}
else
{
PlaylistsViewModel.AlbumPlaylists.Add(( AlbumPlaylist )playlist);
}
}
// Sort the playlists by name
PlaylistsViewModel.SongPlaylists.Sort((a, b) => a.Name.CompareTo(b.Name));
PlaylistsViewModel.AlbumPlaylists.Sort((a, b) => a.Name.CompareTo(b.Name));
// Now copy to the combined list
PlaylistsViewModel.Playlists.Clear();
PlaylistsViewModel.Playlists.AddRange(PlaylistsViewModel.SongPlaylists);
PlaylistsViewModel.Playlists.AddRange(PlaylistsViewModel.AlbumPlaylists);
});
DataReporter?.DataAvailable();
}
/// <summary>
/// Called to delete one or more items from the Now Playing playlist.
/// We need to determine the affect that this deletion may have on the index of the currently playing song.
/// This can be done by examining the track numbers of the items to be deleted
/// </summary>
/// <param name="items"></param>
public static void DeleteNowPlayingItems(IEnumerable <PlaylistItem> items)
{
// Record the currently selected song so its track number can be checked after the delete
PlaylistItem currentPlaylistItem = null;
// If the currently selected song is going to be deleted then invalidate it now
// Only carry out these checks if a song has been selected
if (NowPlayingViewModel.CurrentSongIndex != -1)
{
// Check if the items to delete contains the currently selected song
if (items.Any(item => (item.Index == NowPlayingViewModel.CurrentSongIndex)) == true)
{
// The currently selected song is going to be deleted. Set it to invalid
NowPlayingViewModel.CurrentSongIndex = -1;
new PlaySongMessage()
{
SongToPlay = NowPlayingViewModel.CurrentSong
}.Send();
}
else
{
// Save the current item
currentPlaylistItem = NowPlayingViewModel.NowPlayingPlaylist.PlaylistItems[NowPlayingViewModel.CurrentSongIndex];
}
}
// Delete the entries and report that the list has been updated
NowPlayingViewModel.NowPlayingPlaylist.DeletePlaylistItems(items);
// Adjust the track numbers
NowPlayingViewModel.NowPlayingPlaylist.AdjustTrackNumbers();
// Determine the index of the currently selected song from it's possibly new track number
AdjustSelectedSongIndex(currentPlaylistItem);
// Report change to UI
DataReporter?.DataAvailable();
}
/// <summary> /// Called when a PlaylistUpdatedMessage has been received. Pass it on to the reporter /// </summary> /// <param name="message"></param> private static void PlaylistUpdated(Playlist updatedPlaylist) => DataReporter?.PlaylistUpdated(updatedPlaylist);
/// <summary>
/// Move a set of selected items up the specified playlist and update the track numbers
/// </summary>
/// <param name="thePlaylist"></param>
/// <param name="items"></param>
public static void MoveItemsUp(Playlist thePlaylist, IEnumerable <PlaylistItem> items)
{
thePlaylist.MoveItemsUp(items);
DataReporter?.PlaylistUpdated(thePlaylist);
}
/// <summary> /// Called when the SongSelectedMessage is received /// Inform the reporter /// </summary> /// <param name="message"></param> private static void SongSelected() => DataReporter?.SongSelected();
/// <summary>
/// Sort the available data according to the current sort option
/// </summary>
public static void SortData() => Task.Run(() =>
{
// Use the sort order stored in the model
SortSelector.SortOrder sortOrder = AlbumsViewModel.BaseModel.SortSelector.CurrentSortOrder;
// Clear the indexing collections (in case they are not used in the new sort order)
AlbumsViewModel.FastScrollSections = null;
AlbumsViewModel.FastScrollSectionLookup = null;
// Now do the sorting and indexing according to the sort order
switch (sortOrder)
{
case SortSelector.SortOrder.alphaAscending:
case SortSelector.SortOrder.alphaDescending:
{
if (sortOrder == SortSelector.SortOrder.alphaAscending)
{
AlbumsViewModel.FilteredAlbums.Sort((a, b) => a.Name.RemoveThe().CompareTo(b.Name.RemoveThe()));
}
else
{
AlbumsViewModel.FilteredAlbums.Sort((a, b) => b.Name.RemoveThe().CompareTo(a.Name.RemoveThe()));
}
AlbumsViewModel.Albums = AlbumsViewModel.FilteredAlbums;
GenerateIndex((album, index) => album.Name.RemoveThe().Substring(0, 1).ToUpper());
break;
}
case SortSelector.SortOrder.idAscending:
case SortSelector.SortOrder.idDescending:
{
// If these entries are filtered then order them by the tag id rather than the album id
if (AlbumsViewModel.FilterSelector.CurrentFilter == null)
{
if (sortOrder == SortSelector.SortOrder.idAscending)
{
AlbumsViewModel.FilteredAlbums.Sort((a, b) => a.Id.CompareTo(b.Id));
}
else
{
AlbumsViewModel.FilteredAlbums.Sort((a, b) => b.Id.CompareTo(a.Id));
}
}
else
{
// Form a lookup table from album identity to index in tagged albums.
Dictionary <int, int> albumIdLookup = AlbumsViewModel.FilterSelector.CurrentFilter.TaggedAlbums
.Select((ta, index) => new { ta.AlbumId, index }).ToDictionary(pair => pair.AlbumId, pair => pair.index);
// Order the albums by the album id list
if (sortOrder == SortSelector.SortOrder.idAscending)
{
AlbumsViewModel.FilteredAlbums = AlbumsViewModel.FilteredAlbums.OrderBy(album => albumIdLookup[album.Id]).ToList();
}
else
{
AlbumsViewModel.FilteredAlbums = AlbumsViewModel.FilteredAlbums.OrderByDescending(album => albumIdLookup[album.Id]).ToList();
}
}
// No index required when sorted by Id
AlbumsViewModel.Albums = AlbumsViewModel.FilteredAlbums;
break;
}
case SortSelector.SortOrder.yearAscending:
case SortSelector.SortOrder.yearDescending:
{
if (sortOrder == SortSelector.SortOrder.yearAscending)
{
AlbumsViewModel.FilteredAlbums.Sort((a, b) => a.Year.CompareTo(b.Year));
}
else
{
AlbumsViewModel.FilteredAlbums.Sort((a, b) => b.Year.CompareTo(a.Year));
}
AlbumsViewModel.Albums = AlbumsViewModel.FilteredAlbums;
GenerateIndex((album, index) => album.Year.ToString());
break;
}
case SortSelector.SortOrder.genreAscending:
case SortSelector.SortOrder.genreDescending:
{
// If there is no GenreSortAlbums collection then make one now
if (AlbumsViewModel.GenreSortedAlbums == null)
{
GenerateGenreAlbumList();
}
// We want to keep the AlbumsViewModel.GenreSortedAlbums in ascending order.
// So rather than sort the AlbumsViewModel.GenreSortedAlbums we copy it and sort the copy.
AlbumsViewModel.Albums = AlbumsViewModel.GenreSortedAlbums.ToList();
// We only need to sort if the order is descending
if (sortOrder == SortSelector.SortOrder.genreDescending)
{
// Reverse it
AlbumsViewModel.Albums.Reverse();
}
// Generate the fast lookup indexes. If in reverse order do the genre lookup in reverse order as well
GenerateIndex((album, index) => AlbumsViewModel.AlbumIndexToGenreLookup[
sortOrder == SortSelector.SortOrder.genreAscending ? index : AlbumsViewModel.Albums.Count - 1 - index]);
break;
}
}
// Publish the data
DataReporter?.DataAvailable();
});