public static async void LoadSettings(bool onlyVol = false, bool play = false)
{
var volume = RoamingSettingsHelper.GetSetting <double>(VolKey, 50.0);
if (!onlyVol)
{
_path = RoamingSettingsHelper.GetSetting <string>(PathKey, "");
string folders = RoamingSettingsHelper.GetSetting <string>(FoldersKey, "");
folders.Split('|').ToList().ForEach(async str =>
{
if (!string.IsNullOrEmpty(str))
{
var folder = await StorageFolder.GetFolderFromPathAsync(str);
SharedLogic.SettingsVm.LibraryFoldersCollection.Add(folder);
}
});
// SettingsVM.LibraryFoldersCollection.ToList().ForEach(new Action<StorageFolder>((StorageFolder folder) => { folderPaths += folder.Path + "|"; }));
if (_path != "" && SharedLogic.VerifyFileExists(_path, 300))
{
double position = RoamingSettingsHelper.GetSetting <double>(PosKey, 0);
SharedLogic.Player.PlayerState = PlayerState.Paused;
try
{
Messenger.Instance.NotifyColleagues(MessageTypes.MsgExecuteCmd,
new List <object> {
await StorageFile.GetFileFromPathAsync(_path), position, play, volume
});
}
catch (UnauthorizedAccessException ex)
{
BLogger.Logger.Error("Access denied while trying to play file on startup.", ex);
}
}
}
}
public static async Task RenameFolder(this StorageLibraryChange item, IEnumerable <Mediafile> Library, LibraryService LibraryService)
{
int successCount = 0;
List <Mediafile> ChangedMediafiles = new List <Mediafile>();
//if it's a folder, get all elements in that folder and change their directory
foreach (var mediaFile in await LibraryService.Query(item.PreviousPath.ToUpperInvariant()))
{
var libraryMediafile = Library.First(t => t.Path == mediaFile.Path);
//change the folder path.
//NOTE: this also works for subfolders
mediaFile.FolderPath = mediaFile.FolderPath.Replace(item.PreviousPath, item.Path);
mediaFile.Path = mediaFile.Path.Replace(item.PreviousPath, item.Path);
//verify that the new path exists before updating.
if (SharedLogic.VerifyFileExists(mediaFile.Path, 200))
{
successCount++;
//add to the list so we can update in bulk (it's faster that way.)
ChangedMediafiles.Add(mediaFile);
libraryMediafile.Path = mediaFile.Path;
}
}
if (successCount > 0)
{
//update in bulk.
LibraryService.UpdateMediafiles <Mediafile>(ChangedMediafiles);
await SharedLogic.NotificationManager.ShowMessageAsync(string.Format("{0} Mediafiles Updated. Folder Path: {1}", successCount, item.Path), 5);
}
}
public static async Task RemoveFolder(this StorageLibraryChange change, ThreadSafeObservableCollection <Mediafile> Library, LibraryService LibraryService)
{
int successCount = 0;
List <Mediafile> RemovedMediafiles = new List <Mediafile>();
//iterate all the files in the library that were in
//the deleted folder.
foreach (var mediaFile in await LibraryService.Query(string.IsNullOrEmpty(change.PreviousPath) ? change.Path.ToUpperInvariant() : change.PreviousPath.ToUpperInvariant()))
{
//verify that the file was deleted because it can be a false call.
//we do not want to delete a file that exists.
if (!SharedLogic.VerifyFileExists(mediaFile.Path, 200))
{
RemovedMediafiles.Add(mediaFile);
successCount++;
}
}
if (successCount > 0)
{
Library.RemoveRange(RemovedMediafiles);
await LibraryService.RemoveMediafiles(RemovedMediafiles);
await SharedLogic.NotificationManager.ShowMessageAsync(string.Format("{0} Mediafiles Removed. Folder Path: {1}", successCount, change.Path), 5);
}
}
/// <summary>
/// Asynchronously saves all the album arts in the library.
/// </summary>
/// <param name="Data">ID3 tag of the song to get album art data from.</param>
public static async Task <bool> SaveAlbumArtsAsync(StorageFile file, Mediafile mediafile)
{
var albumArt = AlbumArtFileExists(mediafile);
if (!albumArt.NotExists)
{
return(false);
}
try
{
using (StorageItemThumbnail thumbnail = await file.GetThumbnailAsync(ThumbnailMode.MusicView, 512, ThumbnailOptions.ReturnOnlyIfCached))
{
if (thumbnail == null && SharedLogic.VerifyFileExists(file.Path, 150))
{
using (TagLib.File tagFile = TagLib.File.Create(new SimpleFileAbstraction(file), TagLib.ReadStyle.Average))
{
if (tagFile.Tag.Pictures.Length >= 1)
{
var image = await ApplicationData.Current.LocalFolder.CreateFileAsync(@"AlbumArts\" + albumArt.FileName + ".jpg", CreationCollisionOption.FailIfExists);
using (FileStream stream = new FileStream(image.Path, FileMode.Open, FileAccess.Write, FileShare.None, 51200, FileOptions.WriteThrough))
{
await stream.WriteAsync(tagFile.Tag.Pictures[0].Data.Data, 0, tagFile.Tag.Pictures[0].Data.Data.Length);
}
return(true);
}
}
}
else
{
var albumart = await ApplicationData.Current.LocalFolder.CreateFileAsync(@"AlbumArts\" + albumArt.FileName + ".jpg", CreationCollisionOption.FailIfExists);
IBuffer buf;
Windows.Storage.Streams.Buffer inputBuffer = new Windows.Storage.Streams.Buffer((uint)thumbnail.Size / 2);
using (IRandomAccessStream albumstream = await albumart.OpenAsync(FileAccessMode.ReadWrite))
{
while ((buf = await thumbnail.ReadAsync(inputBuffer, inputBuffer.Capacity, InputStreamOptions.ReadAhead)).Length > 0)
{
await albumstream.WriteAsync(buf);
}
return(true);
}
}
}
}
catch (Exception ex)
{
//await SharedLogic.NotificationManager.ShowMessageAsync(ex.Message + "||" + file.Path);
}
return(false);
}
