/// <summary>
/// Populates the object with metadata from the taglib file object
/// </summary>
protected override void PopulateMediaMetadata()
{
if (!string.IsNullOrEmpty(Path))
{
// try to create the file object
TagLib.File file = null;
try
{
file = TagLib.File.Create(Path);
}
catch { }
// if the file obj was successfully created, get data from it
if (file != null)
{
Artists.AddRange(file.Tag.AlbumArtists);
Album = file.Tag.Album;
Genres.AddRange(file.Tag.Genres);
Composers.AddRange(file.Tag.Composers);
Title = file.Tag.Title;
Year = file.Tag.Year;
Track = file.Tag.Track;
Disc = file.Tag.Disc;
Duration = file.Properties.Duration;
Lyrics = file.Tag.Lyrics;
Comment = file.Tag.Comment;
}
}
}
/// <summary>
/// Component Initialized
/// </summary>
protected override async Task OnInitializedAsync()
{
try
{
var cursorPage = await SpotifyService.GetArtists(AuthenticationService.AuthenticationToken);
Artists.AddRange(cursorPage.Items);
while (cursorPage != null && cursorPage.Next != null)
{
cursorPage = await SpotifyService.GetArtists(AuthenticationService.AuthenticationToken, cursorPage);
Artists.AddRange(cursorPage.Items);
StateHasChanged();
}
await BindPlaylist();
}
catch (Exception ex)
{
this.PageException = ex;
}
Loaded = true;
StateHasChanged();
}
public void Refresh()
{
Clear();
var artists = (from i in _dbref.FindAll()
orderby i.Artist ascending
select i.Artist).Distinct();
Artists.AddRange(artists);
var albums = (from i in _dbref.FindAll()
orderby i.Album ascending
select i.Album).Distinct();
Albums.AddRange(albums);
var geneires = (from i in _dbref.FindAll()
orderby i.Generire ascending
select i.Generire).Distinct();
Geneires.AddRange(geneires);
var years = (from i in _dbref.FindAll()
orderby i.Year ascending
select i.Year).Distinct();
Years.AddRange(years);
}
public void RestoreFrom(Cache ci)
{
Clear();
Albums.AddRange(ci.Albums);
Artists.AddRange(ci.Artists);
Years.AddRange(ci.Years);
Geneires.AddRange(ci.Geneires);
}
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());
}
public void LoadLibrary()
{
var songs = _sqlService.SelectAll <Song>().OrderByDescending(p => p.Id);
var albums = _sqlService.SelectAll <Album>().OrderByDescending(p => p.Id);
var artists = _sqlService.SelectAll <Artist>().OrderByDescending(p => p.Id);
foreach (var song in songs)
{
song.Artist = artists.FirstOrDefault(p => p.Id == song.ArtistId);
song.Album = albums.FirstOrDefault(p => p.Id == song.AlbumId);
}
foreach (var album in albums)
{
album.Songs.AddRange(songs.Where(p => p.AlbumId == album.Id).OrderBy(p => p.TrackNumber));
album.PrimaryArtist = artists.FirstOrDefault(p => p.Id == album.PrimaryArtistId);
if (_dispatcher != null)
{
_dispatcher.RunAsync(CoreDispatcherPriority.Normal,
async() => album.Artwork = await GetArtworkAsync(album.Id)).AsTask().Wait();
}
}
foreach (var artist in artists)
{
artist.Songs.AddRange(songs.Where(p => p.ArtistId == artist.Id));
artist.Albums.AddRange(albums.Where(p => p.PrimaryArtistId == artist.Id));
}
//Foreground app
if (_dispatcher != null)
{
_dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
Songs.AddRange(songs);
Artists.AddRange(artists);
Albums.AddRange(albums);
});
}
//background player
else
{
Songs = new ObservableCollection <Song>(songs);
Artists = new ObservableCollection <Artist>(artists);
Albums = new ObservableCollection <Album>(albums);
}
LoadQueue();
LoadPlaylists();
CleanupFiles();
}
private async Task RefreshAsync()
{
this._offsetCancellationToken?.Cancel();
var newCancel = new CancellationTokenSource();
this._offsetCancellationToken = newCancel;
try
{
if (this._morePage)
{
var catString = SelectedLanguage + SelectedGender;
if (catString.StartsWith("99"))
{
catString = "10" + SelectedGender;
}
if (catString.EndsWith("99"))
{
catString = catString.Substring(0, 2) + "01";
}
var netWorkDataResult = await this._netWorkServices.GetAsync <KeyValuePair <bool, Global.Model.Artist[]> >("FindMusic", "ArtistsList",
new
{
limit = Settings.Default.LimitPerPage,
offset = this._offset,
cat = int.Parse(catString),
initial = SelectedPinYin == "99" ? 0 : Convert.ToChar(SelectedPinYin)
});
if (netWorkDataResult.Successed)
{
var temp = netWorkDataResult.Data;
this._offset++; this._morePage = temp.Key;
Artists.AddRange(temp.Value);
}
else
{
//todo 引发提示信息
}
}
}
catch (OperationCanceledException)
{
}
if (this._offsetCancellationToken == newCancel)
{
this._offsetCancellationToken = null;
}
}
//----------------------------------- ARTISTS -------------------------------------------------------------
public void GetArtists()
{
List <string> genres = new List <string>()
{
"grunge", "rock", "electronic", "metal",
"pop", "alternative", "indie rock",
"Progressive metal", "Hip-Hop", "soul"
};
try
{
foreach (var g in genres)
{
Artists.AddRange(LastFm.GetArtists(g, 10));
}
Artists.ForEach(a => a.Name = a.Name.Replace("&", "And"));
Artists.ForEach(a => a.SqlName = a.Name.Replace("'", "''"));
}
catch (Exception e)
{
throw e;
}
}
public void LoadLibrary()
{
if (IsLibraryLoaded)
{
return;
}
/*
* Sqlite makes a transaction to create a shared lock
* Wrapping it in one single transactions assures it is only lock and release once
*/
_sqlService.BeginTransaction();
var songs = _sqlService.SelectAll <Song>().OrderByDescending(p => p.Id).ToList();
var artists = _sqlService.SelectAll <Artist>().OrderByDescending(p => p.Id).ToList();
var albums = _sqlService.SelectAll <Album>().OrderByDescending(p => p.Id).ToList();
Stations =
new OptimizedObservableCollection <RadioStation>(
_sqlService.SelectAll <RadioStation>().OrderByDescending(p => p.Id).ToList());
// Let go of the lock
_sqlService.Commit();
var isForeground = _dispatcher != null;
foreach (var song in songs)
{
song.Artist = artists.FirstOrDefault(p => p.Id == song.ArtistId);
song.Album = albums.FirstOrDefault(p => p.Id == song.AlbumId);
}
if (isForeground)
{
_dispatcher.RunAsync(() => Songs.AddRange(songs)).Wait();
}
else
{
Songs.AddRange(songs);
}
if (isForeground)
{
foreach (var artist in artists)
{
_dispatcher.RunAsync(
() =>
{
var artworkPath = string.Format(_artistArtworkFilePath, artist.Id);
artist.Artwork = artist.HasArtwork
? _bitmapFactory.CreateImage(
new Uri(_localFilePrefix + artworkPath))
: null;
if (ScaledImageSize != 0 && artist.Artwork != null)
{
artist.Artwork.SetDecodedPixel(ScaledImageSize);
}
}).Wait();
}
}
foreach (var album in albums)
{
album.Songs.AddRange(songs.Where(p => !p.IsTemp && p.AlbumId == album.Id).OrderBy(p => p.TrackNumber));
album.PrimaryArtist = artists.FirstOrDefault(p => p.Id == album.PrimaryArtistId);
if (isForeground)
{
_dispatcher.RunAsync(
() =>
{
var artworkPath = string.Format(_artworkFilePath, album.Id);
if (album.HasArtwork)
{
var path = _localFilePrefix + artworkPath;
album.Artwork = _bitmapFactory.CreateImage(new Uri(path));
if (ScaledImageSize != 0)
{
album.Artwork.SetDecodedPixel(ScaledImageSize);
album.MediumArtwork = _bitmapFactory.CreateImage(new Uri(path));
album.MediumArtwork.SetDecodedPixel(ScaledImageSize / 2);
album.SmallArtwork = _bitmapFactory.CreateImage(new Uri(path));
album.SmallArtwork.SetDecodedPixel(50);
}
}
else
{
var artwork = album.PrimaryArtist.HasArtwork
? album.PrimaryArtist.Artwork
: _missingArtwork;
album.Artwork = artwork;
album.MediumArtwork = artwork;
album.SmallArtwork = artwork;
}
}).Wait();
}
}
if (isForeground)
{
_dispatcher.RunAsync(() => Albums.AddRange(albums)).Wait();
}
else
{
Albums.AddRange(albums);
}
foreach (var artist in artists)
{
artist.Songs.AddRange(songs.Where(p => !p.IsTemp && p.ArtistId == artist.Id).OrderBy(p => p.Name));
artist.Albums.AddRange(
albums.Where(p => p.PrimaryArtistId == artist.Id && p.Songs.Count > 0).OrderBy(p => p.Name));
var songsAlbums = artist.Songs.Select(p => p.Album);
artist.Albums.AddRange(songsAlbums.Where(p => p.Songs.Count > 0 && !artist.Albums.Contains(p)));
}
if (isForeground)
{
_dispatcher.RunAsync(() => Artists.AddRange(artists)).Wait();
}
else
{
Artists.AddRange(artists);
}
IsLibraryLoaded = true;
LoadQueue(songs);
LoadPlaylists();
if (!isForeground)
{
return;
}
var corruptSongs =
Songs.ToList()
.Where(p => string.IsNullOrEmpty(p.Name) || p.Album == null || p.Artist == null)
.ToList();
foreach (var corruptSong in corruptSongs)
{
DeleteSongAsync(corruptSong).Wait();
}
_dispatcher.RunAsync(
() =>
{
if (LibraryLoaded != null)
{
LibraryLoaded(this, null);
}
}).Wait();
try
{
CleanupFiles(albums, artists);
}
catch
{
// ignored
}
}
