public static async Task LoadImageToMemory(AlbumItem item)
{
/*
Normally, We would need more tight calls to try and make sure that the file
exists in our database. However, since this is on the UI thread, we can't do that.
Since binding images directly through XAML leads to blocked files when we
need to delete them, we have to load them up manually. This should be enough
of a check, for now, to make sure images load correctly.
*/
bool fileExists = item.IsPictureLoaded;
try
{
if (fileExists)
{
var file = await StorageFile.GetFileFromApplicationUriAsync(new Uri(item.AlbumCoverFullUri));
using (var stream = await file.OpenAsync(FileAccessMode.Read))
{
await App.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
var image = new BitmapImage();
image.SetSource(stream);
item.AlbumImage = image;
});
}
}
}
catch (Exception)
{
LogHelper.Log("Error getting album picture : " + item.Name);
}
if (!fileExists)
{
await MusicLibraryManagement.FetchAlbumCoverOrWaitAsync(item);
}
}
protected async override void OnActivated(IActivatedEventArgs args)
{
base.OnActivated(args);
try
{
var continueArgs = args as FileOpenPickerContinuationEventArgs;
if (continueArgs != null && continueArgs.Files.Any())
{
switch (OpenFilePickerReason)
{
case OpenFilePickerReason.OnOpeningVideo:
if (Window.Current.Content == null)
{
await LaunchTheApp();
}
await Locator.MediaPlaybackViewModel.OpenFile(continueArgs.Files[0]);
break;
case OpenFilePickerReason.OnOpeningSubtitle:
{
string mru = StorageApplicationPermissions.FutureAccessList.Add(continueArgs.Files[0]);
string mrl = "winrt://" + mru;
Locator.MediaPlaybackViewModel.OpenSubtitle(mrl);
}
break;
case OpenFilePickerReason.OnPickingAlbumArt:
if (continueArgs.Files == null)
{
return;
}
var file = continueArgs.Files.First();
if (file == null)
{
return;
}
var byteArray = await ConvertImage.ConvertImagetoByte(file);
await App.MusicMetaService.SaveAlbumImageAsync(SelectedAlbumItem, byteArray);
await Locator.MusicLibraryVM._albumDatabase.Update(SelectedAlbumItem);
SelectedAlbumItem = null;
break;
}
}
OpenFilePickerReason = OpenFilePickerReason.Null;
}
catch (Exception e)
{
ExceptionHelper.CreateMemorizedException("App.cs.OnActivated", e);
}
}
public static async Task FetchAlbumCoverOrWaitAsync(AlbumItem albumItem)
{
await AlbumCoverFetcherSemaphoreSlim.WaitAsync();
try
{
await albumItem.LoadPicture();
}
finally
{
AlbumCoverFetcherSemaphoreSlim.Release();
}
}
public async Task<bool> GetAlbumCover(AlbumItem album)
{
if (Locator.MainVM.IsInternet && !string.IsNullOrEmpty(album.Name))
{
var bytes = await musicMdFetcher.GetAlbumPictureFromInternet(album.Name, album.Artist);
if (bytes == null)
{
// TODO: Add a TriedWithNoSuccess flag in DB
}
var success = bytes != null && await SaveAlbumImageAsync(album, bytes);
if (success)
{
await Locator.MusicLibraryVM._albumDatabase.Update(album);
return true;
}
}
return false;
}
protected async override void OnActivated(IActivatedEventArgs args)
{
base.OnActivated(args);
try
{
var continueArgs = args as FileOpenPickerContinuationEventArgs;
if (continueArgs != null && continueArgs.Files.Any())
{
switch (OpenFilePickerReason)
{
case OpenFilePickerReason.OnOpeningVideo:
if (Window.Current.Content == null)
await LaunchTheApp();
await Locator.MediaPlaybackViewModel.OpenFile(continueArgs.Files[0]);
break;
case OpenFilePickerReason.OnOpeningSubtitle:
{
string mru = StorageApplicationPermissions.FutureAccessList.Add(continueArgs.Files[0]);
string mrl = "winrt://" + mru;
Locator.MediaPlaybackViewModel.OpenSubtitle(mrl);
}
break;
case OpenFilePickerReason.OnPickingAlbumArt:
if (continueArgs.Files == null) return;
var file = continueArgs.Files.First();
if (file == null) return;
var byteArray = await ConvertImage.ConvertImagetoByte(file);
await App.MusicMetaService.SaveAlbumImageAsync(SelectedAlbumItem, byteArray);
await Locator.MusicLibraryVM._albumDatabase.Update(SelectedAlbumItem);
SelectedAlbumItem = null;
break;
}
}
OpenFilePickerReason = OpenFilePickerReason.Null;
}
catch (Exception e)
{
ExceptionHelper.CreateMemorizedException("App.cs.OnActivated", e);
}
}
public static async Task AddToPlaylist(AlbumItem albumItem)
{
if (Locator.MusicLibraryVM.CurrentTrackCollection == null) return;
var playlistId = Locator.MusicLibraryVM.CurrentTrackCollection.Id;
foreach (TrackItem trackItem in albumItem.Tracks)
{
Locator.MusicLibraryVM.CurrentTrackCollection.Playlist.Add(trackItem);
await Locator.MusicLibraryVM.TracklistItemRepository.Add(new TracklistItem()
{
TrackId = trackItem.Id,
TrackCollectionId = playlistId,
});
}
ToastHelper.Basic(string.Format(Strings.TrackAddedToYourPlaylist, albumItem.Name));
}
static async Task InsertIntoGroupAlbum(AlbumItem album)
{
if (Locator.SettingsVM.AlbumsOrderType == OrderType.ByArtist)
{
var artist = Locator.MusicLibraryVM.GroupedAlbums.FirstOrDefault(x => x.Key == Strings.HumanizedArtistName(album.Artist));
if (artist == null)
{
artist = new GroupItemList<AlbumItem>(album) { Key = Strings.HumanizedArtistName(album.Artist) };
int i = Locator.MusicLibraryVM.GroupedAlbums.IndexOf(Locator.MusicLibraryVM.GroupedAlbums.LastOrDefault(x => string.Compare(x.Key, artist.Key) < 0));
i++;
await App.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () => Locator.MusicLibraryVM.GroupedAlbums.Insert(i, artist));
}
else await App.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () => artist.Add(album));
}
else if (Locator.SettingsVM.AlbumsOrderType == OrderType.ByDate)
{
var year = Locator.MusicLibraryVM.GroupedAlbums.FirstOrDefault(x => x.Key == Strings.HumanizedYear(album.Year));
if (year == null)
{
var newyear = new GroupItemList<AlbumItem>(album) { Key = Strings.HumanizedYear(album.Year) };
int i = Locator.MusicLibraryVM.GroupedAlbums.IndexOf(Locator.MusicLibraryVM.GroupedAlbums.LastOrDefault(x => string.Compare(x.Key, newyear.Key) < 0));
i++;
await App.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () => Locator.MusicLibraryVM.GroupedAlbums.Insert(i, newyear));
}
else await App.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () => year.Add(album));
}
else if (Locator.SettingsVM.AlbumsOrderType == OrderType.ByAlbum)
{
var firstChar = Locator.MusicLibraryVM.GroupedAlbums.FirstOrDefault(x => x.Key == Strings.HumanizedAlbumFirstLetter(album.Name));
if (firstChar == null)
{
var newChar = new GroupItemList<AlbumItem>(album) { Key = Strings.HumanizedAlbumFirstLetter(album.Name) };
int i = Locator.MusicLibraryVM.GroupedAlbums.IndexOf(Locator.MusicLibraryVM.GroupedAlbums.LastOrDefault(x => string.Compare(x.Key, newChar.Key) < 0));
i++;
await App.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () => Locator.MusicLibraryVM.GroupedAlbums.Insert(i, newChar));
}
else await App.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () => firstChar.Add(album));
}
}
public static void AddAlbum(AlbumItem album, ArtistItem artist)
{
artist?.Albums.Add(album);
if (Locator.NavigationService.CurrentPage == VLCPage.MainPageMusic && Locator.MusicLibraryVM.MusicView == MusicView.Albums)
{
Task.Run(() => InsertIntoGroupAlbum(album));
}
Locator.MusicLibraryVM.Albums.Add(album);
}
private static async Task CreateDatabaseFromMusicFile(StorageFile item)
{
try
{
if (!VLCFileExtensions.AudioExtensions.Contains(item.FileType.ToLower())) return;
var media = Locator.VLCService.GetMediaFromPath(item.Path);
MediaProperties mP = Locator.VLCService.GetMusicProperties(media);
if(mP == null)
{
var props = await item.Properties.GetMusicPropertiesAsync();
mP = new MediaProperties()
{
Album = props.Album,
AlbumArtist = props.AlbumArtist,
Artist = props.Artist,
Title = props.Title,
Tracknumber = props.TrackNumber,
Genre = (props.Genre != null && props.Genre.Any()) ? props.Genre[0] : null,
};
}
if (mP != null)
{
var artistName = mP.Artist;
var albumArtistName = mP.AlbumArtist;
ArtistItem artist = Locator.MusicLibraryVM._artistDatabase.LoadViaArtistName(string.IsNullOrEmpty(albumArtistName) ? artistName : albumArtistName);
if (artist == null)
{
artist = new ArtistItem();
artist.Name = string.IsNullOrEmpty(albumArtistName) ? artistName : albumArtistName;
await Locator.MusicLibraryVM._artistDatabase.Add(artist);
await App.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
{
AddArtist(artist);
});
}
var albumName = mP.Album;
var albumYear = mP.Year;
AlbumItem album = await Locator.MusicLibraryVM._albumDatabase.LoadAlbumViaName(artist.Id, albumName);
if (album == null)
{
var albumUrl = Locator.VLCService.GetAlbumUrl(media);
var hasVLCFoundCover = false;
if (!string.IsNullOrEmpty(albumUrl) && albumUrl.StartsWith("file://"))
{
// The Uri will be like
// ms-appdata:///local/vlc/art/artistalbum/30 Seconds To Mars/B-sides & Rarities/art.jpg
hasVLCFoundCover = true;
}
album = new AlbumItem
{
Name = string.IsNullOrEmpty(albumName) ? string.Empty : albumName,
AlbumArtist = albumArtistName,
Artist = string.IsNullOrEmpty(albumArtistName) ? artistName : albumArtistName,
ArtistId = artist.Id,
Favorite = false,
Year = albumYear,
IsPictureLoaded = hasVLCFoundCover,
IsVLCCover = hasVLCFoundCover,
};
await Locator.MusicLibraryVM._albumDatabase.Add(album);
await App.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
{
var artistFromCollection = Locator.MusicLibraryVM.Artists.FirstOrDefault(x => x.Id == album.ArtistId);
AddAlbum(album, artistFromCollection);
Locator.MainVM.InformationText = string.Format(Strings.AlbumsFound, Locator.MusicLibraryVM.Albums.Count);
});
}
TrackItem track = new TrackItem
{
AlbumId = album.Id,
AlbumName = album.Name,
ArtistId = artist.Id,
ArtistName = artistName,
CurrentPosition = 0,
Duration = mP.Duration,
Favorite = false,
Name = string.IsNullOrEmpty(mP.Title) ? item.DisplayName : mP.Title,
Path = item.Path,
Index = mP.Tracknumber,
DiscNumber = mP.DiscNumber,
};
await Locator.MusicLibraryVM._trackDatabase.Add(track);
await App.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () => AddTrack(track));
}
}
catch (Exception e)
{
ExceptionHelper.CreateMemorizedException("MusicLibraryManagement.CreateDatabaseFromMusicFile", e);
}
}
public void Remove(AlbumItem album)
{
if (album == null) return;
var connection = new SQLiteAsyncConnection(DbPath);
connection.DeleteAsync(album);
}
public Task Add(AlbumItem album)
{
var connection = new SQLiteAsyncConnection(DbPath);
return connection.InsertAsync(album);
}
public Task Update(AlbumItem album)
{
var connection = new SQLiteAsyncConnection(DbPath);
return connection.UpdateAsync(album);
}
public async Task<bool> SaveAlbumImageAsync(AlbumItem album, byte[] img)
{
if (await SaveImage(album.Id, "albumPic", img))
{
await App.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
album.AlbumCoverUri = $"albumPic/{album.Id}.jpg";
});
await album.ResetAlbumArt();
return true;
}
return false;
}
