private void OnLibraryUpdated(string s)
{
DispatcherHelper.CheckBeginInvokeOnUI(() => {
Artists.Clear();
LoadArtists();
});
}
public async Task Initialize()
{
Artists.Clear();
Albums.Clear();
Tracks.Clear();
TrackCollections.Clear();
Videos.Clear();
CameraRoll.Clear();
Shows.Clear();
if (_alreadyIndexedOnce)
{
return;
}
_alreadyIndexedOnce = true;
// Doing full indexing from scratch if 0 tracks are found
if (IsMusicDatabaseEmpty() && IsVideoDatabaseEmpty())
{
ClearDatabase();
}
else // Restore the database
{
LoadVideosFromDatabase();
await LoadShowsFromDatabase();
LoadCameraRollFromDatabase();
}
await PerformMediaLibraryIndexing();
}
/// <summary>
/// Retrieves songs from the data source.
/// </summary>
public async void LoadSongs()
{
await DispatcherHelper.ExecuteOnUIThreadAsync(() =>
{
Songs.Clear();
Artists.Clear();
Albums.Clear();
});
var songs = App.Repository.GetAll();
var artists = App.Repository.GetArtists();
var albums = App.Repository.GetAlbums();
await DispatcherHelper.ExecuteOnUIThreadAsync(() =>
{
foreach (var song in songs)
{
Songs.Add(song);
}
foreach (var artist in artists)
{
Artists.Add(artist);
}
foreach (var album in albums)
{
Albums.Add(album);
}
});
}
public override void OnNavigatedTo(NavigatedToEventArgs e, Dictionary <string, object> viewModelState)
{
Tracks = Tracks ?? new SimpleStateSupportCollection <JumpListGroup <VKSaverTrack> >(LoadTracks);
Artists = Artists ?? new SimpleStateSupportCollection <JumpListGroup <VKSaverArtist> >(LoadArtists);
Albums = Albums ?? new SimpleStateSupportCollection <JumpListGroup <VKSaverAlbum> >(LoadAlbums);
Genres = Genres ?? new SimpleStateSupportCollection <JumpListGroup <VKSaverGenre> >(LoadGenres);
Folders = Folders ?? new SimpleStateSupportCollection <VKSaverFolder>(LoadFolders);
Cached = Cached ?? new SimpleStateSupportCollection <JumpListGroup <VKSaverTrack> >(LoadCachedTracks);
if (_libraryDatabaseService.NeedReloadLibraryView)
{
Tracks.Clear();
Artists.Clear();
Albums.Clear();
Genres.Clear();
Folders.Clear();
Cached.Clear();
_libraryDatabaseService.NeedReloadLibraryView = false;
}
if (viewModelState.Count > 0)
{
CurrentPivotIndex = (int)viewModelState[nameof(CurrentPivotIndex)];
}
else
{
string viewName = (string)e.Parameter;
SetPivotIndex(viewName);
}
base.OnNavigatedTo(e, viewModelState);
}
void ClearDatabase()
{
musicDatabase.DeleteAll();
musicDatabase.DeleteAll();
musicDatabase.DeleteAll();
trackCollectionRepository.DeleteAll();
tracklistItemRepository.DeleteAll();
musicDatabase.Initialize();
musicDatabase.Initialize();
musicDatabase.Initialize();
trackCollectionRepository.Initialize();
tracklistItemRepository.Initialize();
Artists.Clear();
Albums.Clear();
Tracks.Clear();
TrackCollections.Clear();
videoDatabase.DeleteAll();
Videos.Clear();
CameraRoll.Clear();
Shows.Clear();
}
private void OnTableSelectionChanged(object sender, RoutedEventArgs e)
{
string selected = TableSelectComboBox.SelectedValue.ToString();
if (selected.Equals("Tracks"))
{
LastNameTextBox.IsEnabled = false;
YearTextBox.IsEnabled = false;
GenreNameTextBox.IsEnabled = false;
DataTable artists = dm.runSelectQuery("select Artists.FirstName from Artists");
Artists.Clear();
foreach (DataRow row in artists.Rows)
{
Artists.Add(row["FirstName"] as string);
}
ArtistSelectComboBox.ItemsSource = Artists;
DataTable albums = dm.runSelectQuery("select Albums.AlbumName from Albums");
Albums.Clear();
foreach (DataRow row in albums.Rows)
{
Albums.Add(row["AlbumName"] as string);
}
AlbumSelectComboBox.ItemsSource = Albums;
}
}
public void ResetMusicContent()
{
Tracks.Clear();
Albums.Clear();
Artists.Clear();
Playlists.Clear();
}
public void Clear()
{
Artists.Clear();
Albums.Clear();
Geneires.Clear();
Years.Clear();
}
public void LoadArtistsFromDatabase()
{
Artists.Clear();
LogHelper.Log("Loading artists from MusicDB ...");
var artists = LoadArtists(null);
LogHelper.Log("Found " + artists.Count + " artists from MusicDB");
Artists.AddRange(artists.OrderBy(x => x.Name).ToObservable());
}
private void PopulateArtists()
{
Artists.Clear();
foreach (string artist in m_DataModel.Database.Artists)
{
Artists.Add(new MusicCollectionItem(artist, Artists.Count));
}
}
public override void Cleanup()
{
_artistsLoaded = _albumsLoaded = _songsLoaded = _genresLoaded = false;
_parentId = null;
Genres.Clear();
Songs.Clear();
Artists.Clear();
Albums.Clear();
SelectedTracks.Clear();
base.Cleanup();
}
private async void Refresh()
{
await ServiceLocator.LocalMusicService.Clear();
if (Tracks != null)
{
Tracks.Clear();
}
if (Artists != null)
{
Artists.Clear();
}
if (Albums != null)
{
Albums.Clear();
}
if (AlbumGroups != null)
{
AlbumGroups.Clear();
}
if (SelectedArtistAlbums != null)
{
SelectedArtistAlbums.Clear();
}
var flyout = new FlyoutControl();
flyout.FlyoutContent = new MusicScanView();
await flyout.ShowAsync();
switch (SelectedTabIndex)
{
case 0:
LoadTracks();
break;
case 1:
LoadAlbums();
break;
case 2:
LoadArtists();
break;
}
}
private void LoadArtists()
{
Artists.Clear();
IList <Artist> artists = administrationService.GetArtists();
foreach (Artist artist in artists)
{
Artists.Add(new ArtistVM(artist, this.administrationService, ioService));
}
CurrentArtist = Artists.First();
var view = CollectionViewSource.GetDefaultView(Artists);
view.GroupDescriptions.Clear();
view.GroupDescriptions.Add(new PropertyGroupDescription("Catagory.Name"));
}
public void Rebuild(IEnumerable <Song> songs)
{
Albums.Clear();
Artists.Clear();
Years.Clear();
Geneires.Clear();
foreach (var s in songs)
{
Albums.Add(s.Album);
Artists.Add(s.Artist);
Years.Add(s.Year.ToString());
Geneires.Add(s.Genre);
}
}
private async Task LoadFromDatabase()
{
await App.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
Artists.Clear();
Tracks.Clear();
});
await MusicLibraryManagement.LoadFromSQL();
await DispatchHelper.InvokeAsync(() =>
{
IsMusicLibraryEmpty = !Artists.Any();
OnPropertyChanged("IsMusicLibraryEmpty");
});
}
public void PopulateArtists(string artistsText)
{
Artists.Clear();
if (!string.IsNullOrEmpty(artistsText))
{
artistsText.Split('|').ToList().ForEach(artist =>
{
if (!string.IsNullOrEmpty(artist))
{
Artists.Add(new ArtistItem(Container)
{
Add = true, ArtistName = artist
});
}
});
}
}
private async void SearchArtists(string query)
{
Artists.Clear();
List <int> foundArtists = await SearchManagerModel.SearchArtists(query);
foreach (int artistId in foundArtists)
{
ArtistViewModel foundArtist = LibraryViewModel.Current.LookupArtistById(artistId);
if (foundArtist != null)
{
Artists.Add(foundArtist);
}
}
artistSearchInProgress = false;
NotifyPropertyChanged(Properties.SearchInProgress);
NotifyPropertyChanged(Properties.ContentInfoArtists);
}
async Task ExecuteLoadCommand()
{
if (IsBusy)
{
return;
}
IsBusy = true;
Artists.Clear();
await Task.Delay(3000);
foreach (Artist a in ArtistsToLoad)
{
Artists.Add(a);
}
IsBusy = false;
}
public void ClearCollection()
{
Artists.Clear();
Genres.Clear();
Directories.Clear();
Songs.Clear();
m_AlbumLookup.Clear();
m_GenreFilteredAlbumLookup.Clear();
m_ArtistExpansion = new SortedDictionary <LibraryItem, ISet <Album> >();
m_AlbumExpansion = new SortedDictionary <LibraryItem, ISet <Song> >();
m_GenreExpansion = new SortedDictionary <LibraryItem, ISet <GenreFilteredAlbum> >();
m_GenreFilteredAlbumExpansion = new SortedDictionary <LibraryItem, ISet <Song> >();
m_DirectoryExpansion = new SortedDictionary <LibraryItem, ISet <LibraryItem> >();
m_ArtistExpansion.Clear();
m_AlbumExpansion.Clear();
m_GenreExpansion.Clear();
m_GenreFilteredAlbumExpansion.Clear();
NotifyPropertyChanged("Database");
}
/// <summary>
/// Populates the list of artists refer to query
/// </summary>
/// <param name="query">string variable to artist searching</param>
/// <returns></returns>
public async Task _SearchArtists(string query)
{
try
{
IsLoading = true;
var artistList = await SpotifyAPI.GetArtists(query.ToLower());
if (artistList != null && artistList.Count > 0)
{
Artists.Clear();
foreach (Artist artist in artistList)
{
Artists.Add(artist);
}
}
IsLoading = false;
}
catch (Exception e)
{
Console.WriteLine("Error Populate Artists");
Console.WriteLine(e.Message);
}
}
/// <summary>
/// Gets artists
/// </summary>
private void GetArtists()
{
User currentUser = Container.Resolve <User>("CurrentUser");
if (currentUser != null)
{
/*
* ArtistsServiceClient serviceClient = Container.Resolve<ArtistsServiceClient>();
* serviceClient.GetArtistsForUser(currentUser.ID,
* (artists) =>
* {*/
// clear existing results
Artists.Clear();
// populate new results
//artists.ForEach(artist => Artists.Add(artist));
Artists.Add(new Artist()
{
Name = "October Tide"
});
Artists.Add(new Artist()
{
Name = "The Devin Townsend Project"
});
Artists.Add(new Artist()
{
Name = "Astomatous"
});
Artists.Add(new Artist()
{
Name = "Carnifex"
});
Artists.Add(new Artist()
{
Name = "Machine Head"
});
Artists.Add(new Artist()
{
Name = "The Atlas Moth"
});
Artists.Add(new Artist()
{
Name = "Norma Jean"
});
Artists.Add(new Artist()
{
Name = "All Shall Perish"
});
Artists.Add(new Artist()
{
Name = "All Else Failed"
});
Artists.Add(new Artist()
{
Name = "All That Remains"
});
Artists.Add(new Artist()
{
Name = "All Pigs Must Die"
});
/*});
*/
}
}
private void OnSongUpdated(int id)
{
Artists.Clear();
LoadArtists();
}
public void RemoveSongs()
{
Artists.Clear();
}
public void Dispose()
{
Artists.Clear();
Albums.Clear();
}
public async Task SearchAsync(string term)
{
if (string.IsNullOrEmpty(term))
{
return;
}
try
{
if (Tracks != null)
{
Tracks.Clear();
_tracksResponse = null;
}
if (Artists != null)
{
Artists.Clear();
_artistsResponse = null;
}
if (Albums != null)
{
Albums.Clear();
_albumsResponse = null;
}
if (LastTracks != null)
{
LastTracks.Clear();
_lastTrackResponse = null;
}
var tasks = new List <Task>
{
Task.Run(
async() =>
{
_tracksResponse = await _spotify.SearchTracksAsync(term);
if (_tracksResponse == null)
{
return;
}
await DispatcherHelper.RunAsync(
() =>
{
Tracks = CreateIncrementalCollection(
() => _tracksResponse,
tracks => _tracksResponse = tracks,
async i => await _spotify.SearchTracksAsync(term, offset: i));
foreach (var lastTrack in _tracksResponse.Items)
{
Tracks.Add(lastTrack);
}
});
}),
Task.Run(
async() =>
{
_albumsResponse = await _spotify.SearchAlbumsAsync(term);
if (_albumsResponse == null)
{
return;
}
await DispatcherHelper.RunAsync(
() =>
{
Albums = CreateIncrementalCollection(
() => _albumsResponse,
albums => _albumsResponse = albums,
async i => await _spotify.SearchAlbumsAsync(term, offset: i));
foreach (var lastAlbum in _albumsResponse.Items)
{
Albums.Add(lastAlbum);
}
});
}),
Task.Run(
async() =>
{
_artistsResponse = await _spotify.SearchArtistsAsync(term);
if (_artistsResponse == null)
{
return;
}
DispatcherHelper.RunAsync(
() =>
{
Artists = CreateIncrementalCollection(
() => _artistsResponse,
artists => _artistsResponse = artists,
async i => await _spotify.SearchArtistsAsync(term, offset: i));
foreach (var lastArtist in _artistsResponse.Items)
{
Artists.Add(lastArtist);
}
});
}),
Task.Run(
async() =>
{
try
{
_lastTrackResponse = await _service.SearchTracksAsync(term);
}
catch
{
// fail silently
}
if (_lastTrackResponse == null)
{
return;
}
await DispatcherHelper.RunAsync(
() =>
{
LastTracks = CreateLastIncrementalCollection(
() => _lastTrackResponse,
artists => _lastTrackResponse = artists,
async i => await _service.SearchTracksAsync(term, i));
foreach (var lastTrack in _lastTrackResponse.Content)
{
LastTracks.Add(lastTrack);
}
});
})
};
await Task.WhenAll(tasks);
}
catch
{
CurtainPrompt.ShowError("AppNetworkIssue".FromLanguageResource());
}
}
private async void SearchFilterChangeCommandExecute()
{
Artists.Clear();
this._morePage = true;
await RefreshAsync();
}
public void InitialiseParts()
{
Albums.Clear();
Artists.Clear();
LoadAlbumAndArtists();
}
