public async void Run(IBackgroundTaskInstance taskInstance)
{
var deferral = taskInstance.GetDeferral();
var posts = await SQLOperator.Current().GetPodcastListBriefAsync();
var tasks = new List <Task>();
foreach (var item in posts)
{
tasks.Add(Task.Run(async() =>
{
var p = new Podcast(item);
try
{
if (await p.FindUpdated() && Settings.Current.IsPodcastToast)
{
Toast.SendPodcast(p);
Tile.UpdatePodcast($"podcast{p.ID}", p);
}
}
catch (Exception)
{
}
}));
}
await Task.WhenAll(tasks);
deferral.Complete();
}
public static async Task <int> CountAsync <T>() where T : new()
{
if (typeof(T) == typeof(Song))
{
return(await SQLOperator.Current().CountAsync <SONG>());
}
if (typeof(T) == typeof(Album))
{
return(await SQLOperator.Current().CountAsync <ALBUM>());
}
if (typeof(T) == typeof(Artist))
{
return(await SQLOperator.Current().CountAsync <Artist>());
}
if (typeof(T) == typeof(PlayList))
{
return(await SQLOperator.Current().CountAsync <PLAYLIST>());
}
if (typeof(T) == typeof(Podcast))
{
return(await SQLOperator.Current().CountAsync <PODCAST>());
}
if (typeof(T) == typeof(StorageFolder))
{
return(await SQLOperator.Current().CountAsync <FOLDER>());
}
return(await SQLOperator.Current().CountAsync <T>());
}
public AddPlayList()
{
InitializeComponent();
RequestedTheme = Settings.Current.Theme;
Task.Run(async() =>
{
var list = await SQLOperator.Current().GetPlayListBriefAsync();
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, async() =>
{
foreach (var item in list)
{
Playlists.Add(new PlayListViewModel(item));
}
await Task.Delay(200);
if (list.Count > 0)
{
Main.SelectedIndex = 0;
}
else
{
IsPrimaryButtonEnabled = false;
}
});
});
}
public async Task ReadFileandSave(IEnumerable <StorageFile> files)
{
var opr = SQLOperator.Current();
var total = files.Count();
int i = 1;
var newlist = new List <SONG>();
foreach (var file in files)
{
if (!file.IsAvailable || file.Attributes.HasFlag(FileAttributes.LocallyIncomplete))
{
ProgressUpdated?.Invoke(this, new ProgressReport()
{
Description = $"{i} of {total} files readed", Current = i, Total = total
});
i++;
continue;
}
try
{
using (var tagTemp = File.Create(file.Path))
{
var song = await Song.Create(tagTemp.Tag, file.Path, await file.Properties.GetMusicPropertiesAsync());
var t = await opr.InsertSongAsync(song);
if (t != null)
{
newlist.Add(t);
}
}
}
catch (Exception e)
{
Shared.Helpers.Tools.Logging(e);
continue;
}
finally
{
ProgressUpdated?.Invoke(this, new ProgressReport()
{
Description = $"{i} of {total} files read", Current = i, Total = total
});
i++;
}
}
if (newlist.Count > 0)
{
await AddToAlbums(newlist);
}
else
{
Completed?.Invoke(this, EventArgs.Empty);
}
}
public static async Task <int> GetArtistsCountAsync()
{
var opr = SQLOperator.Current();
var artists = await opr.GetArtistsAsync();
return(artists.Count);
}
public static async Task <List <Song> > GetAllSongAsync()
{
var opr = SQLOperator.Current();
var songs = await opr.GetAllAsync <SONG>();
return(songs.ConvertAll(x => new Song(x)));
}
public async static Task SortAlbums()
{
await Task.Run(async() =>
{
var opr = SQLOperator.Current();
var songs = await opr.GetAllAsync <SONG>();
var albums = from song in songs group song by song.Album into album select album;
var count = albums.Count();
int i = 1;
var scan = Consts.Localizer.GetString("AlbumSortText");
ProgressUpdated?.Invoke(null, new ProgressReport()
{
Description = SmartFormat.Smart.Format(scan, 0, count), Current = 0, Total = count
});
foreach (var item in albums)
{
await opr.AddAlbumAsync(item);
ProgressUpdated?.Invoke(null, new ProgressReport()
{
Description = SmartFormat.Smart.Format(scan, i, count), Current = i, Total = count
});
i++;
}
Completed?.Invoke(null, EventArgs.Empty);
});
}
internal async Task <IList <Song> > GetSongsAsync()
{
var opr = SQLOperator.Current();
var albums = await opr.GetAlbumsOfArtistAsync(RawName);
return(await opr.GetSongsAsync(albums.SelectMany(s => s.Songs)));
}
public async static Task <List <Album> > GetAlbumsAsync()
{
var opr = SQLOperator.Current();
var albums = await opr.GetAllAsync <ALBUM>();
return(albums.ConvertAll(a => new Album(a)));
}
internal async Task AddToAlbums(IEnumerable <SONG> songs)
{
await Task.Run(async() =>
{
var albums = from song in songs group song by song.Album into album select album;
var opr = SQLOperator.Current();
var count = albums.Count();
if (count == 0)
{
Completed?.Invoke(this, EventArgs.Empty);
return;
}
int i = 1;
await Task.Delay(200);
ProgressUpdated?.Invoke(this, new ProgressReport()
{
Description = $"0 of {count} albums sorted", Current = 0, Total = count
});
foreach (var item in albums)
{
await opr.AddAlbumAsync(item);
ProgressUpdated?.Invoke(this, new ProgressReport()
{
Description = $"{i} of {count} albums sorted", Current = i, Total = count
});
i++;
}
Completed?.Invoke(this, EventArgs.Empty);
});
}
public static async Task <List <Album> > GetAlbumsAsync(string value)
{
var opr = SQLOperator.Current();
// get single song
// sqlite escaping
value = SQLOperator.SQLEscaping(value);
if (value.IsNullorEmpty())
{
// anonymous artists, get their songs
var songs = await opr.GetWithQueryAsync <SONG>("ALBUMARTISTS", value);
var albumGrouping = from song in songs group song by song.Album;
return(albumGrouping.ToList().ConvertAll(a => new Album(a)));
}
// get aritst-associated albums
var albums = await opr.GetWithQueryAsync <ALBUM>("ALBUMARTISTS", value);
var res = albums.ConvertAll(a => new Album(a));
var otherSongs = await opr.GetWithQueryAsync <SONG>($"SELECT * FROM SONG WHERE PERFORMERS='{value}' OR ALBUMARTISTS='{value}'");
// remove duplicated (we suppose that artist's all song is just 1000+, this way can find all song and don't take long time)
otherSongs.RemoveAll(x => !albums.Where(b => b.Name == x.Album).IsNullorEmpty());
var otherGrouping = from song in otherSongs group song by song.Album;
// otherSongs has item
if (!otherGrouping.IsNullorEmpty())
{
res.AddRange(otherGrouping.ToList().ConvertAll(a => new Album(a)));
}
return(res);
}
public static async Task <List <StorageFile> > FindChanges(List <StorageFile> list)
{
var opr = SQLOperator.Current();
var filePaths = await opr.GetFilePathsAsync();
list.Distinct(new StorageFileComparer());
foreach (var path in filePaths)
{
try
{
var file = await StorageFile.GetFileFromPathAsync(path);
if (list.Find(x => x.Path == file.Path) is StorageFile f)
{
list.Remove(f);
}
else
{
await opr.RemoveSongAsync(path);
}
}
catch (FileNotFoundException)
{
await opr.RemoveSongAsync(path);
}
}
return(list);
}
internal GenericMusicItem(ALBUM s)
{
InnerType = MediaType.Album;
ContextualID = s.ID;
Title = s.Name;
var songs = s.Songs.Split(new string[] { "|" }, StringSplitOptions.RemoveEmptyEntries);
var ids = Array.ConvertAll(songs, (a) =>
{
return(int.Parse(a));
});
Description = SmartFormat.Smart.Format(Consts.Localizer.GetString("SmartSongs"), ids.Length);
Addtional = s.AlbumArtists.IsNullorEmpty() ? Consts.UnknownArtists : string.Join(Consts.CommaSeparator, s.AlbumArtists.Split(new string[] { Consts.ArraySeparator }, StringSplitOptions.RemoveEmptyEntries));
var songIDs = AsyncHelper.RunSync(async() => await SQLOperator.Current().GetSongsAsync(ids));
var s1 = songIDs.OrderBy(a => a.Track);
s1 = s1.OrderBy(a => a.Disc);
IDs = s1.Select(b => b.ID).ToArray();
var t = ThreadPool.RunAsync(async work =>
{
s.Songs = string.Join('|', songIDs.Select(x => x.ID.ToString()));
if (s.Songs.IsNullorEmpty())
{
await SQLOperator.Current().RemoveAlbumAsync(s.ID);
}
else
{
await SQLOperator.Current().UpdateAlbumAsync(s);
}
});
PicturePath = s.PicturePath;
}
public async static Task <Podcast> ReadFromLocalAsync(int iD)
{
var p = await SQLOperator.Current().GetItemByIDAsync <PODCAST>(iD);
var fileName = p.XMLPath;
try
{
var folder = await ApplicationData.Current.LocalFolder.CreateFolderAsync("Podcasts", CreationCollisionOption.OpenIfExists);
var file = await folder.TryGetItemAsync($"{fileName}.xml");
if (file == null)
{
return(null);
}
var str = await FileIO.ReadTextAsync(file as StorageFile);
var a = new Podcast
{
XMLUrl = p.XMLUrl,
XMLPath = p.XMLPath,
Subscribed = p.Subscribed,
SortRevert = p.SortRevert,
ID = p.ID,
};
await a.ReadXML(str);
return(a);
}
catch (Exception)
{
return(null);
}
}
public static async Task <List <StorageFile> > FindChanges()
{
var opr = SQLOperator.Current();
var filePaths = await opr.GetFilePathsAsync();
var foldersDB = await opr.GetAllAsync <FOLDER>();
var folders = FileReader.InitFolderList();
foreach (var f in foldersDB)
{
StorageFolder folder = await f.GetFolderAsync();
if (folders.Exists(a => a.Path == folder.Path))
{
continue;
}
folders.Add(folder);
}
var list = new List <StorageFile>();
foreach (var item in folders)
{
if (item == null)
{
continue;
}
var options = new Windows.Storage.Search.QueryOptions
{
FileTypeFilter = { ".flac", ".wav", ".m4a", ".aac", ".mp3" },
FolderDepth = Windows.Storage.Search.FolderDepth.Deep,
IndexerOption = Windows.Storage.Search.IndexerOption.DoNotUseIndexer,
};
var query = item.CreateFileQueryWithOptions(options);
var files = await query.GetFilesAsync();
list.AddRange(files);
var t = Task.Run(async() => { await opr.UpdateFolderAsync(item, files.Count); });
}
list.Distinct(new StorageFileComparer());
foreach (var path in filePaths)
{
try
{
var file = await StorageFile.GetFileFromPathAsync(path);
if (list.Find(x => x.Path == file.Path) is StorageFile f)
{
list.Remove(f);
}
}
catch (FileNotFoundException)
{
await opr.RemoveSongAsync(path);
}
}
return(list);
}
private async void SearchButton_Click(object sender, RoutedEventArgs e)
{
switch (SearchButton.Visibility)
{
case Visibility.Collapsed:
SearchBoxCollapse.Begin();
return;
default:
break;
}
SearchBoxShow.Begin();
SearchBox.Focus(FocusState.Programmatic);
if (SearchBox.Text.IsNullorEmpty())
{
Context.SearchItems.Clear();
// add clipboard text
DataPackageView dataPackageView = Clipboard.GetContent();
if (dataPackageView.Contains(StandardDataFormats.Text))
{
string text = await dataPackageView.GetTextAsync();
if (!string.IsNullOrWhiteSpace(text))
{
Context.SearchItems.Add(new GenericMusicItemViewModel()
{
Title = text,
InnerType = MediaType.Placeholder,
Description = "\uE16D",
});
}
}
// add search history
var searches = await SQLOperator.Current().GetSearchHistoryAsync();
foreach (var item in searches)
{
Context.SearchItems.Add(new GenericMusicItemViewModel()
{
Title = item.Query,
InnerType = MediaType.Placeholder,
Description = "\uE81C",
});
}
}
if (!SearchBox.Items.IsNullorEmpty())
{
SearchBox.IsSuggestionListOpen = true;
}
else
{
SearchBox.IsSuggestionListOpen = false;
}
}
public static async Task PlayStaticAdd(int id, int targetType, int addAmount)
{
var opr = SQLOperator.Current();
if (targetType == 0)
{
await opr.SongCountAddAsync(id, addAmount);
}
}
private async void CreateRootFrame(ApplicationExecutionState previousExecutionState)
{
rootFrame = Window.Current.Content as Frame;
// Do not repeat app initialization when the Window already has content,
// just ensure that the window is active
if (rootFrame == null)
{
// Create a Frame to act as the navigation context and navigate to the first page
rootFrame = new Frame
{
// Set the default language
// Language = Windows.Globalization.ApplicationLanguages.Languages[0]
};
rootFrame.NavigationFailed += OnNavigationFailed;
if (previousExecutionState == ApplicationExecutionState.Terminated)
{
//TODO: Load state from previously suspended application
}
// Place the frame in the current Window
Window.Current.Content = rootFrame;
}
CoreApplication.GetCurrentView().TitleBar.ExtendViewIntoTitleBar = true;
var titleBar = ApplicationView.GetForCurrentView().TitleBar;
titleBar.ButtonBackgroundColor = Colors.Transparent;
titleBar.ButtonInactiveBackgroundColor = Colors.Transparent;
if (ui != null)
{
ui.ColorValuesChanged -= Ui_ColorValuesChanged;
}
ui = new UISettings();
ui.ColorValuesChanged += Ui_ColorValuesChanged;
titleBar.ButtonHoverBackgroundColor = ui.GetColorValue(UIColorType.AccentDark1);
ApplicationView.GetForCurrentView().SetDesiredBoundsMode(ApplicationViewBoundsMode.UseVisible);
// if you want not to have any window smaller than this size...
ApplicationView.GetForCurrentView().SetPreferredMinSize(new Windows.Foundation.Size(320, 320));
var s = Settings.Current;
SQLOperator.Current();
ImageCache.Instance.CacheDuration = TimeSpan.MaxValue;
ImageCache.Instance.RetryCount = 1;
await ImageCache.Instance.InitializeAsync(ApplicationData.Current.LocalFolder, "Cache");
}
internal async Task <AlbumViewModel> GetAlbumAsync()
{
if (IsOnline)
{
if (Song.OnlineAlbumID.IsNullorEmpty())
{
return(null);
}
return(new AlbumViewModel(await MainPageViewModel.Current.GetOnlineAlbumAsync(Song.OnlineAlbumID)));
}
return(new AlbumViewModel(await SQLOperator.Current().GetAlbumByNameAsync(Song.Album, Song.ID)));
}
public async void WriteFav(bool isCurrentFavorite)
{
if (IsOnline)
{
// TODO: throw new NotImplementedException("WriteFav on online");
return;
}
else
{
await SQLOperator.Current().WriteFavoriteAsync(ID, isCurrentFavorite);
}
}
public async Task <bool> GetFavoriteAsync()
{
if (IsOnline)
{
// TODO: get fac online
return(false);
}
else
{
return(await SQLOperator.Current().GetFavoriteAsync(ID));
}
}
public async void Run(IBackgroundTaskInstance taskInstance)
{
var d = taskInstance.GetDeferral();
//await FileIOHelper.AppendLogtoCacheAsync("DownloadCompletor start");
var sa = await SQLOperator.Current().GetAllAsync <DownloadDesc>();
BackgroundTransferCompletionGroupTriggerDetails details = taskInstance.TriggerDetails
as BackgroundTransferCompletionGroupTriggerDetails;
if (details == null)
{
// This task was not triggered by a completion group.
return;
}
List <DownloadOperation> failedDownloads = new List <DownloadOperation>();
foreach (DownloadOperation download in details.Downloads)
{
if (IsFailed(download))
{
failedDownloads.Add(download);
}
else
{
try
{
//await FileIOHelper.AppendLogtoCacheAsync($"success of {download.ResultFile.Name}");
var p = sa.Find(a => a.Guid == download.Guid);
sa.Remove(p);
Toast.SendDownload(p);
await SQLOperator.Current().RemoveDownloadDes(p);
//await FileIOHelper.AppendLogtoCacheAsync($"send toast of {download.ResultFile.Name}");
}
catch (Exception)
{
}
}
}
if (failedDownloads.Count > 0)
{
//await RetryDownloads(failedDownloads, sa);
}
await FileIOHelper.AppendLogtoCacheAsync("Complete");
d.Complete();
}
private async Task FindFileChangesAsync()
{
var foldersDB = await SQLOperator.Current().GetAllAsync <FOLDER>();
var filtered = new List <string>();
var folders = FileReader.InitFolderList();
foreach (var fo in foldersDB)
{
var folder = await fo.GetFolderAsync();
if (folders.Exists(a => a.Path == folder.Path))
{
continue;
}
if (fo.IsFiltered)
{
filtered.Add(folder.DisplayName);
}
else
{
folders.Add(folder);
}
}
try
{
folders.Remove(folders.Find(a => a.Path == ApplicationData.Current.LocalFolder.Path));
}
catch (Exception)
{
}
foreach (var item in folders)
{
trackers.Add(new FileTracker(item, filtered));
}
var files = new List <StorageFile>();
foreach (var item in trackers)
{
files.AddRange(await item.SearchFolder());
}
var addedFiles = await FileTracker.FindChanges(files);
if (!(addedFiles.Count == 0))
{
await FileReader.ReadFileandSaveAsync(addedFiles);
}
}
public async Task WriteRatingAsync(double rat)
{
if (IsOnline)
{
throw new NotImplementedException("WriteRatingAsync on online");
}
else
{
var file = await StorageFile.GetFileFromPathAsync(FilePath);
var prop = await file.Properties.GetMusicPropertiesAsync();
uint r;
if (rat < 0)
{
r = 0;
}
else
{
if (rat < 1)
{
r = 0;
}
else if (rat < 1.5)
{
r = 19;
}
else if (rat < 2.5)
{
r = 39;
}
else if (rat < 3.5)
{
r = 59;
}
else if (rat < 4.5)
{
r = 79;
}
else
{
r = 99;
}
}
prop.Rating = r;
await prop.SavePropertiesAsync();
Rating = (rat < 0 ? 0 : rat);
await SQLOperator.Current().UpdateSongRatingAsync(ID, Rating);
}
}
internal async Task RemoveFolder(FolderViewModel folderViewModel)
{
var opr = SQLOperator.Current();
await opr.RemoveFolderAsync(folderViewModel.ID);
Folders.Remove(folderViewModel);
if (MainPageViewModel.Current != null)
{
var t = Task.Run(async() =>
{
await MainPageViewModel.Current.FilesChangedAsync();
});
}
}
public static async Task <List <GenericMusicItem> > Search(string text)
{
var opr = SQLOperator.Current();
text = SQLOperator.SQLEscaping_LIKE(text);
var songs = await opr.SearchAsync <SONG>(text, "TITLE", "PERFORMERS");
var album = await opr.SearchAsync <ALBUM>(text, "NAME", "AlbumArtists");
var l = new List <GenericMusicItem>(album.ConvertAll(x => new GenericMusicItem(x)));
l.AddRange(songs.ConvertAll(x => new GenericMusicItem(x)));
return(l);
}
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());
}
internal async void ChangeSort(int selectedIndex)
{
var songs = await SQLOperator.Current().GetSongsAsync(Model.SongsID);
IEnumerable <GroupedItem <SongViewModel> > grouped;
switch (selectedIndex)
{
case 0:
grouped = GroupedItem <SongViewModel> .CreateGroupsByAlpha(songs.ConvertAll(x => new SongViewModel(x)));
break;
case 1:
grouped = GroupedItem <SongViewModel> .CreateGroups(songs.ConvertAll(x => new SongViewModel(x)), x => x.FormattedAlbum);
break;
case 2:
grouped = GroupedItem <SongViewModel> .CreateGroups(songs.ConvertAll(x => new SongViewModel(x)), x => x.GetFormattedArtists());
break;
default:
grouped = GroupedItem <SongViewModel> .CreateGroups(songs.ConvertAll(x => new SongViewModel(x)), x => x.Song.Year, true);
break;
}
SongsList.Clear();
foreach (var item in grouped)
{
item.Aggregate((x, y) =>
{
y.Index = x.Index + 1;
return(y);
});
SongsList.Add(item);
}
foreach (var item in SongsList)
{
foreach (var song in item)
{
song.RefreshFav();
}
}
}
public async Task GetSongsAsync(AlbumViewModel a)
{
Album = a;
await a.GetSongsAsync();
await CoreApplication.MainView.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, () =>
{
SongList.Clear();
for (int i = 0; i < a.Songs.Count; i++)
{
SongList.Add(new SongViewModel(a.Songs[i])
{
Index = (uint)i
});
}
foreach (var item in SongList)
{
item.RefreshFav();
}
});
var info = await MainPageViewModel.Current.GetAlbumInfoAsync(Album.Name, Album.AlbumArtists.FirstOrDefault());
await CoreApplication.MainView.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, () =>
{
if (info != null)
{
if (Album.Artwork == null && info.AltArtwork != null)
{
Album.ArtworkUri = info.AltArtwork;
var task = ThreadPool.RunAsync(async k =>
{
if (!Album.IsOnline)
{
await SQLOperator.Current().UpdateAlbumArtworkAsync(album.ID, info.AltArtwork.OriginalString);
}
});
}
Album.Description = info.Description;
}
else
{
Album.Description = $"# {Consts.Localizer.GetString("LocaAlbumTitle")}";
}
});
}
public async Task GetArtists()
{
var opr = SQLOperator.Current();
var artists = await opr.GetArtistsAsync();
var grouped = GroupedItem <ArtistViewModel> .CreateGroupsByAlpha(artists.ConvertAll(x => new ArtistViewModel
{
Name = x.AlbumArtists,
SongsCount = x.Count
}));
await CoreApplication.MainView.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, () =>
{
ArtistList.Clear();
long sum = 0;
foreach (var item in grouped)
{
ArtistList.Add(item);
sum += item.Sum(x => x.SongsCount);
}
ArtistsCount = SmartFormat.Smart.Format(Consts.Localizer.GetString("SmartArtists"), artists.Count);
SongsCount = SmartFormat.Smart.Format(Consts.Localizer.GetString("SmartSongs"), sum);
var t = ThreadPool.RunAsync(async x =>
{
foreach (var item in ArtistList)
{
foreach (var art in item)
{
var uri = await opr.GetAvatarAsync(art.RawName);
if (Uri.TryCreate(uri, UriKind.Absolute, out var u))
{
await CoreApplication.MainView.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Low, () =>
{
art.Avatar = u;
});
}
else
{
}
}
}
});
});
}
