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 { } } } }); }); }