public static async Task SavePlaylist(PlaylistFile playlist)
{
var pathPlaylists = await ApplicationData.Current.LocalFolder.GetFolderAsync("Playlists");
StorageFile filePlaylist;
try
{
filePlaylist = await pathPlaylists.GetFileAsync($"Id{playlist.Id}.json");
}
catch
{
filePlaylist = await pathPlaylists.CreateFileAsync($"Id{playlist.Id}.json");
}
var jsonString = JsonConvert.SerializeObject(playlist);
try
{
await FileIO.WriteTextAsync(filePlaylist, jsonString);
}catch (Exception e)
{
await ContentDialogService.Show(new ExceptionDialog("Невозможно сохранить плейлист", "Возможно, этот плейлист уже существует.", e));
}
}
public static async Task SaveConfig(ConfigApp config)
{
try
{
var configFile = await StaticContent.LocalFolder.GetFileAsync("ConfigApp.json");
var configString = JsonConvert.SerializeObject(config);
await FileIO.WriteTextAsync(configFile, configString);
}catch (Exception e)
{
await ContentDialogService.Show(new ExceptionDialog("Не удалось сохранить настройки приложения", "Возможно, файл занят другим приложением, если ошибка будет повторятся, переустановите приложение", e));
}
}
public async static Task PurchaseAddOn(string storeId)
{
if (context == null)
{
context = StoreContext.GetDefault();
}
StorePurchaseResult result = await context.RequestPurchaseAsync(storeId);
string extendedError = string.Empty;
if (result.ExtendedError != null)
{
extendedError = result.ExtendedError.Message;
}
switch (result.Status)
{
case StorePurchaseStatus.AlreadyPurchased:
var settings = ApplicationData.Current.LocalSettings;
settings.Values["IsPro"] = true;
await ContentDialogService.Show(new ThanksBuyProContentDialog());
break;
case StorePurchaseStatus.Succeeded:
var settings2 = ApplicationData.Current.LocalSettings;
settings2.Values["IsPro"] = true;
StaticContent.IsPro = true;
await ContentDialogService.Show(new ThanksBuyProContentDialog());
break;
case StorePurchaseStatus.NotPurchased:
await new MessageDialog($"Произошла ошибка при покупке Music X Pro: {extendedError}", "Покупка Music X Pro").ShowAsync();
break;
case StorePurchaseStatus.NetworkError:
await new MessageDialog($"Невозможно купить Music X Pro из-за проблем с интернет-подключением", "Покупка Music X Pro").ShowAsync();
break;
case StorePurchaseStatus.ServerError:
await new MessageDialog($"Произошла ошибка на серере при покупке Music X Pro: {extendedError}", "Покупка Music X Pro").ShowAsync();
break;
default:
await new MessageDialog($"Произошла неизвестная на сервере при покупке Music X Pro: {extendedError}", "Покупка Music X Pro").ShowAsync();
break;
}
}
/// <summary>
/// Перейти на страницу
/// </summary>
/// <param name="page">Страница</param>
/// <param name="data">Данные</param>
public void Go(Type page, object data = null)
{
try
{
if (this.Pages.Count > 0)
{
if (this.Pages.Peek() == page)
{
return;
}
}
this.Pages.Push(page);
this.UpdateButtonBack();
this.RootFrame.CacheSize = 3;
this.RootFrame.Navigate(page, data);
}catch (Exception e)
{
ContentDialogService.Show(new ExceptionDialog("Невозможно перейти на страницу", "Попробуйте перезапустить приложение", e), 1);
}
}
public static async Task SetPlaylistLocal()
{
try
{
var pathPlaylists = await ApplicationData.Current.LocalFolder.GetFolderAsync("Playlists");
var files = await pathPlaylists.GetFilesAsync();
foreach (var file in files)
{
var json = await FileIO.ReadTextAsync(file);
var playlist = JsonConvert.DeserializeObject <PlaylistFile>(json);
StaticContent.Playlists.Add(playlist);
}
}catch (Exception e)
{
await ContentDialogService.Show(new ExceptionDialog("Невозможно получить список плейлистов", "Вам стоит переустановить приложение, если эта ошибка не изчезнет.", e));
}
}
public async static Task <PlaylistFile> GetById(long id)
{
var pathPlaylists = await ApplicationData.Current.LocalFolder.GetFolderAsync("Playlists");
StorageFile file;
try
{
file = await pathPlaylists.GetFileAsync($"Id{id}.json");
} catch (Exception e)
{
await ContentDialogService.Show(new ExceptionDialog("Невозможно получить плейлист", "Возможно, этого плейлиста больше не существует.", e));
return(null);
}
var json = await FileIO.ReadTextAsync(file);
var model = JsonConvert.DeserializeObject <PlaylistFile>(json);
return(model);
}
public static async Task DeletePlaylist(PlaylistFile playlist)
{
try
{
if (playlist.Id == 1 || playlist.Id == 1000)
{
var dialog = new MessageDialog("Данный плейлист невозможно удалить.",
"Невозможно удалить плейлист");
await dialog.ShowAsync();
return;
}
var folder = StaticContent.PlaylistsFolder;
StaticContent.Playlists.Remove(playlist);
var file = await folder.GetFileAsync($"Id{playlist.Id}.json");
await file.DeleteAsync();
}catch (Exception e)
{
await ContentDialogService.Show(new ExceptionDialog("Невозможно удалить плейлист", "Возможно, этот плейлист уже был удален или он поврежден.", e));
}
}
public static async Task PlayPlaylist(PlaylistFile playlist)
{
try
{
if (playlist.TracksFiles.Count == 0)
{
var dialog = new MessageDialog("В данном плейлисте отсутсвуют треки. Пожалуйста, добавте в него треки.",
"Невозможно возпроизвести плейлист");
await dialog.ShowAsync();
return;
}
var folder = StaticContent.PlaylistsFolder;
if (StaticContent.NowPlayPlaylist == playlist)
{
return;
}
await PlayMusicService.PlayMusicForLibrary(playlist.TracksFiles[0], 3, playlist);
}catch (Exception e)
{
await ContentDialogService.Show(new ExceptionDialog("Невозможно воспроизвести плейлист", "Возможно, он поврежден или он не существует", e));
}
}
public static async Task GetMusicLocal(bool refresh = false)
{
try
{
var musicLocal = await GetLocalMusicCollection();
if (musicLocal.DateLastUpdate == "none")
{
refresh = true;
}
if (refresh)
{
musicLocal.Music.Clear();
StaticContent.Music.Clear();
if (StaticContent.Config.FindInMusicLibrary)
{
var files = await KnownFolders.MusicLibrary.GetFilesAsync(CommonFileQuery.OrderByName);
foreach (var f in files)
{
if (f.FileType == ".mp3" || f.FileType == ".wav" || f.FileType == ".flac")
{
AudioFile track;
track = await FindMetadataService.ConvertToAudioFile(f);
musicLocal.Music.Add(track);
StaticContent.Music.Add(track);
}
}
}
if (StaticContent.Config.FindInDocumentsLibrary)
{
var folder = KnownFolders.DocumentsLibrary;
var files = (await folder.GetFilesAsync(Windows.Storage.Search.CommonFileQuery.OrderByDate)).ToList();
foreach (var f in files)
{
if (f.FileType == ".mp3" || f.FileType == ".wav" || f.FileType == ".flac")
{
AudioFile track;
track = await FindMetadataService.ConvertToAudioFile(f);
musicLocal.Music.Add(track);
StaticContent.Music.Add(track);
}
}
}
musicLocal.DateLastUpdate = $"{DateTime.Now.Day}.{DateTime.Now.Month} в {DateTime.Now.Hour}: {DateTime.Now.Minute}";
var fileMusic = await StaticContent.LocalFolder.GetFileAsync("MusicCollection.json");
var json = JsonConvert.SerializeObject(musicLocal);
await FileIO.WriteTextAsync(fileMusic, json);
}
else
{
foreach (var track in musicLocal.Music)
{
if (track.Source == null)
{
track.Source = await StorageFile.GetFileFromPathAsync(track.SourceString);
}
track.Duration = TimeSpan.FromSeconds(track.DurationSeconds);
StaticContent.Music.Add(track);
}
}
}catch (Exception e)
{
await ContentDialogService.Show(new ExceptionDialog("Ошибка при поиске файлов", "Возможно, нет доступа к папке", e));
}
}
public async static Task PlayMusicForLibrary(AudioFile audioFile, int typePlay, PlaylistFile playlistPlay = null)
{
try
{
if (audioFile == null)
{
return;
}
//type play:
//1 - проигрования из списка треков
//2 - проигрование трека по клику на него
//3 - проигрование трека из плейлиста
StaticContent.AudioService.Seek(TimeSpan.Zero);
var lastPlayPlaylist = await PlaylistsService.GetById(1);
if (audioFile.Source == null)
{
audioFile.Source = await StorageFile.GetFileFromPathAsync(audioFile.SourceString);
}
if (!(lastPlayPlaylist.TracksFiles.Any(t => t.SourceString == audioFile.SourceString)))
{
lastPlayPlaylist.TracksFiles.Add(audioFile);
await PlaylistsService.SavePlaylist(lastPlayPlaylist);
}
var playlistNowPlay = new PlaylistFile()
{
Artist = "Music X",
Cover = "ms-appx:///Assets/Images/now.png",
Id = 1000,
Name = "Сейчас играет",
TracksFiles = new List <AudioFile>(),
IsLocal = true
};
if (typePlay == 1)
{
foreach (var trackMusic in StaticContent.Music)
{
playlistNowPlay.TracksFiles.Add(trackMusic);
}
StaticContent.NowPlayPlaylist = playlistNowPlay;
StaticContent.AudioService.SetCurrentPlaylist(playlistNowPlay.ToAudioPlaylist(), false);
StaticContent.AudioService.CurrentPlaylist.CurrentItem = audioFile;
}
else if (typePlay == 2)
{
StaticContent.NowPlayPlaylist = playlistNowPlay;
StaticContent.NowPlayPlaylist.TracksFiles.Add(audioFile);
StaticContent.AudioService.SetCurrentPlaylist(playlistNowPlay.ToAudioPlaylist());
}
else if (typePlay == 3)
{
StaticContent.NowPlayPlaylist = playlistPlay;
var index = 0;
try
{
index = playlistPlay.Tracks.IndexOf(playlistPlay.Tracks.Single(t => t.Id == audioFile.Id));
}catch
{
index = playlistPlay.TracksFiles.IndexOf(playlistPlay.TracksFiles.Single(t => t.Id == audioFile.Id));
}
if (index != 0)
{
StaticContent.AudioService.SetCurrentPlaylist(playlistPlay.ToAudioPlaylist(), false);
StaticContent.AudioService.CurrentPlaylist.CurrentItem = audioFile;
}
else
{
StaticContent.AudioService.SetCurrentPlaylist(playlistPlay.ToAudioPlaylist(), true);
}
}
if (!(StaticContent.Playlists.Any(p => p.Id == 1000)))
{
StaticContent.Playlists.Insert(0, StaticContent.NowPlayPlaylist);
}
}catch (Exception e)
{
await ContentDialogService.Show(new ExceptionDialog("Невозможно возпроизвести трек.", "Возможно, файл не поддерживается или поврежден.", e));
}
}
public async static Task <AudioFile> ConvertToAudioFile(StorageFile file)
{
var mp3FileAbs = new FileMp3Abstraction()
{
Name = file.Name,
ReadStream = await file.OpenStreamForReadAsync(),
WriteStream = await file.OpenStreamForWriteAsync(),
};
try
{
using (var mp3File = TagLib.File.Create(mp3FileAbs))
{
AudioFile audio = new AudioFile();
if (mp3File.Tag.AlbumArtists.Count() != 0)
{
audio.Artist = mp3File.Tag.AlbumArtists[0];
}
else
{
if (mp3File.Tag.Artists.Count() != 0)
{
audio.Artist = mp3File.Tag.Artists[0];
}
else
{
audio.Artist = "Неизвестный исполнитель";
}
}
if (mp3File.Tag.Title != null)
{
audio.Title = mp3File.Tag.Title;
}
else
{
audio.Title = file.DisplayName;
}
audio.DurationSeconds = mp3File.Properties.Duration.TotalSeconds;
audio.DurationMinutes = Converters.AudioTimeConverter.Convert(mp3File.Properties.Duration.TotalSeconds);
audio.Duration = mp3File.Properties.Duration;
audio.Id = (file.Name.GetHashCode() * 1);
audio.InternalId = 0;
audio.OwnerId = 0;
audio.IsLocal = true;
audio.PlaylistId = 0;
if (mp3File.Tag.Pictures.Any())
{
StorageFolder localFolder = ApplicationData.Current.LocalFolder;
var alah = StaticContent.CoversFolder.TryGetItemAsync($"{audio.Id}.jpg");
System.IO.File.WriteAllBytes($"{localFolder.Path}/Covers/{audio.Id}.jpg", mp3File.Tag.Pictures[0].Data.Data);
audio.Cover = $"{localFolder.Path}/Covers/{audio.Id}.jpg";
}
else
{
audio.Cover = "ms-appx:///Assets/Images/placeholder.png";
}
audio.Source = file;
audio.SourceString = file.Path;
var playlist = await Services.PlaylistsService.GetById(2);
audio.IsFavorite = playlist.TracksFiles.Any(t => t.SourceString == audio.SourceString);
audio.IsInLibrary = true;
audio.IsDownload = true;
return(audio);
}
}
catch (CorruptFileException)
{
return(null);
}catch (Exception e)
{
AudioFile audio = new AudioFile()
{
Artist = "Неизвестный исполнитель",
Cover = "ms-appx:///Assets/Images/placeholder.png",
Duration = TimeSpan.Zero,
DurationMinutes = "00:00",
DurationSeconds = 0,
Id = 0,
InternalId = 0,
OwnerId = 0,
PlaylistId = 0,
Source = file,
SourceString = "ms-appx:///Assets/Audio/song.mp3",
Title = file.DisplayName
};
await ContentDialogService.Show(new ExceptionDialog("Ошибка при обработке файла", $"Файл {file.Name} не может быть обработан по неизвестной причине", e));
return(audio);
}
}
