/// <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 async Task SearchExecute()
{
try
{
if (string.IsNullOrWhiteSpace(SearchQuery))
{
await ClearExecute();
return;
}
await ExecuteBusyAction(async() =>
{
Songs.Clear();
var songs = await YoutubeSearchService.SearchVideo($"{SearchQuery} karaoke", 1);
foreach (var song in songs)
{
Songs.Add(song);
}
});
}
catch (System.Exception ex)
{
Debug.WriteLine(ex);
}
}
private void RefreshSongs()
{
Songs.Clear();
MusicFolders = DataService.GetSavedSearchFolders();
if (MusicFolders.Count == 0)
{
ErrorString = "Add Folders Where You Store Your Music To Get Started!";
SelectedMenuItem = "Settings";
}
else
{
ErrorString = string.Empty;
}
foreach (string folder in MusicFolders)
{
Songs = DataService.GetSongs(folder);
}
// Load ID3 Tags And Fill Albums
Task.Run(() =>
{
LoadSongID3Tags();
Songs.OrderBy(s => s.Artist.StartsWith("A ", StringComparison.OrdinalIgnoreCase) || s.Artist.StartsWith("The ", StringComparison.OrdinalIgnoreCase) ? s.Artist.Substring(s.Artist.IndexOf(" ") + 1) : s.Artist);
RefreshAlbums();
});
}
public async Task ViewLoadedAsync()
{
if (DataIsLoaded)
{
return;
}
var caller = $"{nameof(AlbumViewModel)}({_instanceId:N}).{nameof(ViewLoadedAsync)}";
try
{
BusyStatus = "Getting data ...";
IsBusy = true;
Songs.Clear();
Personnel.Clear();
var album = await Services.DataService.GetAlbumAsync(Id);
IsBusy = false;
(album as BaseResponse)?.To(this as BaseViewModel);
album?.Data?.Album?.To(this);
DataIsLoaded = true;
}
catch (Exception ex)
{
var errorId = Invariant($"{DateTime.Now:yyyyMMdd_HHmmss}");
Logger.Log.Error(ex, "Failed to load band by id.", caller, errorId);
IsBusy = false;
MessageBoxService.ShowMessage($"Failed to get album details.{Environment.NewLine}{ex.Message}{Environment.NewLine}See log for more info. Error id is {errorId}.", WindowTitle, MessageButton.OK, MessageIcon.Error);
}
}
public void NewPlaylist()
{
Songs.Clear();
MediaMetadata.Clear();
OpenFileDialog dlg = new OpenFileDialog();
dlg.Filter = "All Media Files|*.wav;*.aac;*.wma;*.wmv;*.avi;*.mpg;*.mpeg;*.m1v;*.mp2;*.mp3;*.mpa;*.mpe;*.m3u;*.mp4;*.mov;*.3g2;*.3gp2;*.3gp;*.3gpp;*.m4a;*.cda;*.aif;*.aifc;*.aiff;*.mid;*.midi;*.rmi;*.mkv;*.WAV;*.AAC;*.WMA;*.WMV;*.AVI;*.MPG;*.MPEG;*.M1V;*.MP2;*.MP3;*.MPA;*.MPE;*.M3U;*.MP4;*.MOV;*.3G2;*.3GP2;*.3GP;*.3GPP;*.M4A;*.CDA;*.AIF;*.AIFC;*.AIFF;*.MID;*.MIDI;*.RMI;*.MKV";
dlg.Multiselect = true;
DialogResult dialogResult = dlg.ShowDialog();
if (dialogResult == System.Windows.Forms.DialogResult.OK)
{
foreach (String file in dlg.FileNames)
{
Songs.Add(file);
_element = new TagLibMetadata(file);
if (_element.MetaDataTL.Tag.Title == null)
{
_element.MetaDataTL.Tag.Title = "Unknown";
}
//if (element.MetaDataTL.Tag.Performers.Length < 0)
//{
// element.MetaDataTL.Tag.Performers = new string[1] { "Unknown" };
// element.MetaDataTL.Save();
//}
//element.MetaDataTL.Tag.Performers[0] = "Unknown";
MediaMetadata.Add(_element);
}
IndexList = new int[Songs.Count];
for (int i = 0; i < Songs.Count; i++)
{
IndexList[i] = i;
}
}
}
public Task UpdateMusicLibraryAsync()
{
return(Task.Run(() =>
{
App.Current.Dispatcher.Invoke(() =>
{
Songs.Clear();
if (Properties.Settings.Default.MusicFolderPath != null)
{
foreach (string path in Properties.Settings.Default.MusicFolderPath)
{
foreach (var item in Directory.GetFiles(path, "*.mp3*", SearchOption.AllDirectories))
{
Song song = new Song(item);
if (!Songs.Contains(song))
{
Songs.Add(song);
}
}
}
}
});
}));
}
public void SortByTitle()
{
List <string> names = new List <string>();
List <Song> sorted = new List <Song>();
foreach (var song in Songs)
{
names.Add(song.Title);
}
names.Sort();
foreach (var name in names)
{
foreach (var song in Songs)
{
if (song.Title == name)
{
sorted.Add(song);
continue;
}
}
}
Songs.Clear();
Songs.AddRange(sorted);
}
public void Dispose()
{
PlaylistArt = null;
TotalSongs = "0";
TotalMinutes = "0";
Songs.Clear();
}
public void Reset()
{
PlaylistArt = null;
TotalSongs = "0";
TotalMinutes = "0";
Songs.Clear();
}
// 重新读取本地歌曲信息
public async void ReloadSongs()
{
// 清空数据
ObservableCollection <Song> tempSongs = new ObservableCollection <Song>(Songs);
Songs.Clear();
DBManager.ClearSongs("_Songs_");
try {
foreach (Song s in tempSongs)
{
try
{
var t = await StorageFile.GetFileFromPathAsync(s.FilePath);
}
catch (Exception ex)
{
tempSongs.Remove(s);
}
}
}
catch (Exception ex)
{
}
Songs = tempSongs;
DBManager.AddSongs(Songs, "_Songs_");
Songs.CollectionChanged += Songs_CollectionChanged;
}
/// <summary>
/// Removes all songs from the playlist.
/// </summary>
public void Clear()
{
if (Songs.Count == 0)
{
return;
}
Songs.Clear();
IsDirty = true;
}
protected virtual void PlayerDisconnected(string user)
{
if (session.Username == user)
{
Songs.Clear();
SyncPlaylist(Songs);
Delete(fileName);
}
}
public async Task LoadAsync()
{
var lookup = await _songLookupService.GetSongLookupAsync();
Songs.Clear();
foreach (var item in lookup)
{
Songs.Add(new NavigationItemViewModel(item.Id, item.DisplayMember, _eventAggregator));
}
}
// Add list of songs in collection that fill list in view
private void FillSongList(string path)
{
var songs = fileService.Open(path);
Songs.Clear();
foreach (var song in songs)
{
Songs.Add(song);
}
}
protected override void Dispose(bool disposing)
{
Songs.Clear();
Originals.Clear();
Covers.Clear();
Aliases.Clear();
Songs = null;
Originals = null;
Covers = null;
Aliases = null;
base.Dispose(disposing);
}
public override async Task SetPlaylist(MusicItem song)
{
if (await CanModifyPlaylist())
{
Songs.Clear();
await OnUiThread(() => player.NowPlaying = song);
// updates local playlist first; assumes upload is successful
await Add(song);
await Stream(song, "/stream");
}
}
//-------------------------- ▶ EventHandlers
async void OpenButton_Click(object sender, RoutedEventArgs e)
{
FolderPicker folderPicker = new FolderPicker()
{
ViewMode = PickerViewMode.Thumbnail,
SuggestedStartLocation = PickerLocationId.MusicLibrary,
CommitButtonText = "선택",
};
folderPicker.FileTypeFilter.Add(".mp3");
folderPicker.FileTypeFilter.Add(".wmv");
StorageFolder storageFolder = await folderPicker.PickSingleFolderAsync();
if (storageFolder == null)
{
return;
}
IReadOnlyList <StorageFile> allItems = await storageFolder.GetFilesAsync();
if (allItems.Count < 0)
{
return;
}
var onlyMusics = allItems.Where(c => c.ContentType == "audio/mpeg");
if (onlyMusics.Count() <= 0)
{
return;
}
if (Songs == null)
{
Songs = new ObservableCollection <Song>();
}
else
{
Songs.Clear();
}
foreach (var music in onlyMusics)
{
Song song = new Song()
{
StorageFile = music,
MusicProperties = await music.Properties.GetMusicPropertiesAsync()
};
Songs.Add(song);
}
}
private void RefreshData()
{
int selection = SelectedSong;
Songs.Clear();
foreach (var item in Repository.LoadAll())
{
Songs.Add(item);
}
SelectedSong = selection;
}
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 Task LoadSongs()
{
if (Songs != null && Songs.Count > 0)
{
Songs.Clear();
}
var songs = await songRepository.GetAllSongAsync();
foreach (var song in songs)
{
Songs.Add(new SongViewModel(song));
}
AllSongsCopy = Songs;
}
internal async Task <List <Song> > GetSongsAsync()
{
if (IsOnline && Songs != null && Songs.Count > 0)
{
return(Songs);
}
if (Songs.Count == SongsID.Length)
{
return(Songs);
}
Songs.Clear();
var opr = SQLOperator.Current();
var s = await opr.GetSongsAsync(SongsID);
var s1 = s.OrderBy(x => x.Track);
s1 = s1.OrderBy(x => x.Disc);
Songs.AddRange(s1);
var t = ThreadPool.RunAsync(async work =>
{
SongsID = s.Select(x => x.ID).ToArray();
if (SongsID.IsNullorEmpty())
{
await SQLOperator.Current().RemoveAlbumAsync(ID);
}
else
{
await SQLOperator.Current().UpdateAlbumAsync(new Album(ID)
{
Songs = SongsID,
Name = Name ?? string.Empty,
Genres = Genres ?? new string[] { },
Year = Year,
AlbumSort = AlbumSort ?? string.Empty,
TrackCount = TrackCount,
DiscCount = DiscCount,
AlbumArtists = AlbumArtists ?? new string[] { },
AlbumArtistsSort = AlbumArtistsSort ?? new string[] { },
ReplayGainAlbumGain = ReplayGainAlbumGain,
ReplayGainAlbumPeak = ReplayGainAlbumPeak,
PicturePath = ArtworkUri == null ? string.Empty : ArtworkUri.AbsolutePath ?? string.Empty,
});
}
});
return(s1.ToList());
}
public void LoadSongs(string file)
{
// empty songs list
Songs.Clear();
string[] rows = File.ReadAllLines(file);
foreach (string row in rows)
{
// row = "song name;length"
string[] parts = row.Split(new char[] { ';' }); // käytetään csv. parsintaan tiedostossa käytettyä merkkiä
// parts[0] = "song name", parts[1] = length
Song song = new Song();
song.Name = parts[0];
song.Length = int.Parse(parts[1]);
Songs.Add(song);
}
}
public async Task ClearAllAsync()
{
var message = $"Are you sure you want to delete all songs in the album " +
$"'{Album.Name}' " +
$"by '{Album.Performer.Name}'?";
if (MessageBox.Show(message, "Confirmation", MessageBoxButton.YesNo) == MessageBoxResult.Yes)
{
foreach (var song in Songs.Where(song => song.Id != -1))
{
await _songService.RemoveSongAsync(song.Id);
}
Songs.Clear();
}
}
/// <summary>
/// UnloadContent will be called once per game and is the place to unload
/// all content.
/// </summary>
protected override void UnloadContent()
{
Textures.Clear();
Fonts.Clear();
SoundEffects.Clear();
Songs.Clear();
ContentManager.Unload();
#if DEBUG
SpartaDebug.DebugFont = null;
#endif
backgroundImage = null;
base.UnloadContent();
GC.Collect();
}
public async void FilterSongsByAlbum(string albumName)
{
if (string.IsNullOrEmpty(albumName))
{
return;
}
var songs = App.Repository.GetAll();
var filteredSongs = songs.Where(x => x.Album.Name.Equals(albumName));
await DispatcherHelper.ExecuteOnUIThreadAsync(() =>
{
Songs.Clear();
foreach (var song in filteredSongs)
{
Songs.Add(song);
}
});
}
public void Shuffle()
{
List <Song> suffledSongs = new List <Song>();
int step = 3;
for (int i = 0; i < step; i++)
{
int index = i;
while (index < Songs.Count)
{
suffledSongs.Add(Songs[index]);
index += step;
}
}
Songs.Clear();
Songs.AddRange(suffledSongs);
}
public async void FilterSongsByName(string songName)
{
if (string.IsNullOrEmpty(songName))
{
return;
}
var songs = App.Repository.GetAll();
var filteredSongs = songs.Where(x => x.Title.Contains(songName, StringComparison.OrdinalIgnoreCase));
await DispatcherHelper.ExecuteOnUIThreadAsync(() =>
{
Songs.Clear();
foreach (var song in filteredSongs)
{
Songs.Add(song);
}
});
}
private async void SearchSongs(string query)
{
Songs.Clear();
List <int> foundSongs = await SearchManagerModel.SearchSongs(query);
foreach (int songId in foundSongs)
{
SongViewModel foundSong = LibraryViewModel.Current.LookupSongById(songId);
if (foundSong != null)
{
Songs.Add(foundSong);
}
}
songSearchInProgress = false;
NotifyPropertyChanged(Properties.SearchInProgress);
NotifyPropertyChanged(Properties.ContentInfoSongs);
}
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");
}
public void Dispose()
{
foreach (var song in Songs)
{
if (song.Artist?.Albums != null)
{
foreach (var artistAlbum in song.Artist.Albums)
{
artistAlbum.Songs?.Clear();
artistAlbum.Artist = null;
}
}
song.Artist?.Albums?.Clear();
song.Album = null;
song.Artist = null;
}
Songs?.Clear();
_db?.Dispose();
_db = null;
Initialized = false;
}