public static Song ToSong(this LocalSong track) { var song = new Song { ProviderId = "local." + track.Id, Name = track.Title, ArtistName = track.ArtistName, Duration = track.Duration, AudioUrl = track.FilePath, SongState = SongState.Local, TrackNumber = track.TrackNumber, HeartState = track.HeartState }; if (!string.IsNullOrEmpty(track.ArtistId)) { song.Artist = track.ToArtist(); if (string.IsNullOrEmpty(song.ArtistName)) { song.ArtistName = song.Artist.Name; } } if (!string.IsNullOrEmpty(track.AlbumId)) { song.Album = track.ToAlbum(); song.Album.PrimaryArtist = song.Artist; } return song; }
public static async Task PlaySongsAsync(Song song, List<Song> songs, bool forceClear = false) { if (song == null || songs == null || songs.Count == 0) return; var skip = songs.IndexOf(song); var ordered = songs.Skip(skip).ToList(); ordered.AddRange(songs.Take(skip)); var overflow = songs.Count - MaxMassPlayQueueCount; if (overflow > 0) for (var i = 0; i < overflow; i++) ordered.Remove(ordered.LastOrDefault()); var playbackQueue = App.Current.Locator.CollectionService.PlaybackQueue.ToList(); var sameLength = _currentlyPreparing || songs.Count < playbackQueue.Count || playbackQueue.Count >= MaxMassPlayQueueCount; var containsSong = playbackQueue.FirstOrDefault(p => p.SongId == song.Id) != null; var createQueue = forceClear || (!sameLength || !containsSong); if (_currentlyPreparing && createQueue) { //cancel the previous _currentlyPreparing = false; //wait for it to stop await Task.Delay(50); } if (!createQueue) { AudioPlayerHelper.PlaySong(playbackQueue.First(p => p.SongId == song.Id)); } else { // using (Insights.TrackTime("Create Queue", "Count", ordered.Count.ToString())) // { _currentlyPreparing = true; await App.Current.Locator.CollectionService.ClearQueueAsync().ConfigureAwait(false); var queueSong = await App.Current.Locator.CollectionService.AddToQueueAsync(song).ConfigureAwait(false); AudioPlayerHelper.PlaySong(queueSong); App.Current.Locator.SqlService.BeginTransaction(); for (var index = 1; index < ordered.Count; index++) { if (!_currentlyPreparing) break; var s = ordered[index]; await App.Current.Locator.CollectionService.AddToQueueAsync(s).ConfigureAwait(false); } App.Current.Locator.SqlService.Commit(); _currentlyPreparing = false; // } } }
public static Song ToSong(this LastTrack track) { var song = new Song { ProviderId = !string.IsNullOrEmpty(track.Mbid) ? ("mbid." + track.Mbid) : ("lastid." + track.Id), Name = track.Name.Trim().Replace(" ", " ") }; return song; }
/// <summary> /// Drop all refrences to the data item /// </summary> public void ClearData() { _queueMode = true; _playlistMode = true; _song = null; SongNameTextBlock.ClearValue(TextBlock.TextProperty); ArtistAlbumNameTextBlock.ClearValue(TextBlock.TextProperty); DataContext = null; }
public static Song ToSong(this SimpleTrack track) { var song = new Song { ProviderId = "spotify." + track.Id, Name = track.Name.Trim().Replace(" ", " "), TrackNumber = track.TrackNumber }; return song; }
public bool CanScrobble(Song song, TimeSpan position) { /* When is a scrobble a scrobble? * A track should only be scrobbled when the following conditions have been met: * 1. The track must be longer than 30 seconds. * 2. And the track has been played for at least half its duration, or for 4 minutes (whichever occurs earlier.) */ var playbackTime = position.TotalSeconds; var duration = song.Duration.TotalSeconds; return duration >= 30 && (playbackTime >= duration/2 || playbackTime >= 60*4); }
/// <summary> /// This method visualizes the placeholder state of the data item. When /// showing a placehlder, we set the opacity of other elements to zero /// so that stale data is not visible to the end user. /// </summary> /// <param name="song">The song.</param> /// <param name="queueMode">if set to <c>true</c> [queue mode].</param> /// <param name="playlistMode">if set to <c>true</c> [playlist mode].</param> public void ShowPlaceholder(Song song, bool queueMode = false, bool playlistMode = false) { _playlistMode = playlistMode; _queueMode = queueMode; DownloadOptionGrid.Visibility = Visibility.Collapsed; DownloadProgressGrid.Visibility = Visibility.Collapsed; DataContext = song; _song = song; SongNameTextBlock.Opacity = 0; ArtistAlbumNameTextBlock.Opacity = 0; AlbumTrackNumber.Visibility = Visibility.Collapsed; }
public async Task AddSongAsync(Song song, Tag tags = null) { var primaryArtist = (song.Album == null ? song.Artist : song.Album.PrimaryArtist) ?? new Artist {Name = "Unknown Artist", ProviderId = "autc.unknown"}; var artist = _inProgressArtists.Union(Artists).FirstOrDefault( entry => entry.ProviderId == primaryArtist.ProviderId || string.Equals(entry.Name, primaryArtist.Name, StringComparison.CurrentCultureIgnoreCase)); if (artist == null) { await _sqlService.InsertAsync(primaryArtist); _inProgressArtists.Add(primaryArtist); song.Artist = primaryArtist; song.ArtistId = primaryArtist.Id; if (song.Album != null) { song.Album.PrimaryArtistId = song.Artist.Id; song.Album.PrimaryArtist = song.Artist; } } else { song.Artist = artist; if (song.Album != null) { song.Album.PrimaryArtistId = artist.Id; song.Album.PrimaryArtist = artist; } } song.ArtistId = song.Artist.Id; if (song.Album == null) { song.Album = new Album { PrimaryArtistId = song.ArtistId, Name = song.Name, PrimaryArtist = song.Artist, ProviderId = "autc.single." + song.ProviderId }; } var album = _inProgressAlbums.Union(Albums).FirstOrDefault(p => p.ProviderId == song.Album.ProviderId); if (album != null) { song.Album = album; } else { await _sqlService.InsertAsync(song.Album); _inProgressAlbums.Add(song.Album); await _dispatcher.RunAsync(() => { var artwork = song.Artist.HasArtwork ? song.Artist.Artwork : _missingArtwork; song.Album.Artwork = artwork; song.Album.MediumArtwork = artwork; song.Album.SmallArtwork = artwork; }); if (tags != null && tags.Pictures != null && tags.Pictures.Length > 0) { var albumFilePath = string.Format(_artworkFilePath, song.Album.Id); Stream artwork = null; var image = tags.Pictures.FirstOrDefault(); if (image != null) { artwork = new MemoryStream(image.Data.Data); } if (artwork != null) { using (artwork) { try { var file = await StorageHelper.CreateFileAsync( albumFilePath, option: CreationCollisionOption.ReplaceExisting); using (var fileStream = await file.OpenAsync(FileAccess.ReadAndWrite)) { var bytes = tags.Pictures[0].Data.Data; await fileStream.WriteAsync(bytes, 0, bytes.Length); song.Album.HasArtwork = true; await _sqlService.UpdateItemAsync(song.Album); } } catch { // ignored } } } // set it if (song.Album.HasArtwork) { await _dispatcher.RunAsync( () => { var path = _localFilePrefix + albumFilePath; song.Album.Artwork = _bitmapFactory.CreateImage(new Uri(path)); if (ScaledImageSize == 0) { return; } song.Album.Artwork.SetDecodedPixel(ScaledImageSize); song.Album.MediumArtwork = _bitmapFactory.CreateImage(new Uri(path)); song.Album.MediumArtwork.SetDecodedPixel(ScaledImageSize/2); song.Album.SmallArtwork = _bitmapFactory.CreateImage(new Uri(path)); song.Album.SmallArtwork.SetDecodedPixel(50); }); } } } song.AlbumId = song.Album.Id; if (string.IsNullOrEmpty(song.ArtistName)) song.ArtistName = song.Artist.Name; await _sqlService.InsertAsync(song); await _dispatcher.RunAsync( () => { if (!song.IsTemp) { var orderedAlbumSong = song.Album.Songs.ToList(); orderedAlbumSong.Add(song); orderedAlbumSong = orderedAlbumSong.OrderBy(p => p.TrackNumber).ToList(); var index = orderedAlbumSong.IndexOf(song); song.Album.Songs.Insert(index, song); var orderedArtistSong = song.Artist.Songs.ToList(); orderedArtistSong.Add(song); orderedArtistSong = orderedArtistSong.OrderBy(p => p.Name).ToList(); index = orderedArtistSong.IndexOf(song); song.Artist.Songs.Insert(index, song); #region Order artist album if (!song.Artist.Albums.Contains(song.Album)) { var orderedArtistAlbum = song.Artist.Albums.ToList(); orderedArtistAlbum.Add(song.Album); orderedArtistAlbum = orderedArtistAlbum.OrderBy(p => p.Name).ToList(); index = orderedArtistAlbum.IndexOf(song.Album); song.Artist.Albums.Insert(index, song.Album); } #endregion } _inProgressAlbums.Remove(song.Album); _inProgressArtists.Remove(song.Artist); if (!Albums.Contains(song.Album)) Albums.Add(song.Album); else if (song.Album.Songs.Count == 1) { // This means the album was added with a temp song // Have to remove and readd it to get it to show up Albums.Remove(song.Album); Albums.Add(song.Album); } if (!Artists.Contains(song.Artist)) Artists.Add(song.Artist); else if (song.Artist.Songs.Count == 1) { // This means the album was added with a temp song // Have to remove and readd it to get it to show up Artists.Remove(song.Artist); Artists.Add(song.Artist); } Songs.Add(song); }); }
public async Task DeleteSongAsync(Song song) { var queueSong = PlaybackQueue.FirstOrDefault(p => p.SongId == song.Id); if (queueSong != null) { await DeleteFromQueueAsync(queueSong); } // remove it from artist, albums and playlists songs var playlists = Playlists.Where(p => p.Songs.Count(pp => pp.SongId == song.Id) > 0).ToList(); foreach (var playlist in playlists) { var songs = playlist.Songs.Where(p => p.SongId == song.Id).ToList(); foreach (var playlistSong in songs) { await DeleteFromPlaylistAsync(playlist, playlistSong); } if (playlist.Songs.Count == 0) { await DeletePlaylistAsync(playlist); } } if (song.Album != null) { song.Album.Songs.Remove(song); // If the album is empty, make sure that is not being used by any temp song if (song.Album.Songs.Count == 0 && Songs.Count(p => p.AlbumId == song.AlbumId) < 2) { await _sqlService.DeleteItemAsync(song.Album); await _dispatcher.RunAsync( () => { Albums.Remove(song.Album); if (song.Artist != null) song.Artist.Albums.Remove(song.Album); }); } } if (song.Artist != null) { song.Artist.Songs.Remove(song); if (song.Artist.Songs.Count == 0 && Songs.Count(p => p.ArtistId == song.ArtistId) < 2) { await _sqlService.DeleteItemAsync(song.Artist); await _dispatcher.RunAsync( () => { Artists.Remove(song.Artist); }); } } // good, now lets delete it from the db await _sqlService.DeleteItemAsync(song); await _dispatcher.RunAsync(() => Songs.Remove(song)); }
private void DownloadClickExecute(Song song) { _downloadService.StartDownloadAsync(song); }
private async Task AddToQueueAsync(Song song) { if (QueueSongs.Any(p => p.SongId == song.Id)) return; var prev = QueueSongs.LastOrDefault(); // Create the new queue entry var newQueue = new QueueSong { SongId = song.Id, PrevId = prev == null ? 0 : prev.Id, Song = song }; using (var bg = _bgFunc()) { await bg.InsertAsync(newQueue); if (prev != null) { prev.NextId = newQueue.Id; await bg.UpdateItemAsync(prev); } QueueSongsLookup.Add(newQueue.Id, newQueue); QueueSongs.Add(newQueue); } }
private void CancelClickExecute(Song song) { if (song.Download != null) { _downloadService.Cancel(song.Download); } else { song.SongState = SongState.None; _sqlService.UpdateItemAsync(song); } }
public static async Task<QueueSong> AddToQueueAsync( Song song, bool shuffleInsert = true, bool playIfNotActive = true, bool clearIfNotActive = true, bool ignoreInsertMode = false) { if (!song.IsMatched) { CurtainPrompt.ShowError("Can't add unmatch songs to queue."); } QueueSong queueSong; using (var handle = Insights.TrackTime("Add Song To Queue")) { if (_currentlyPreparing) { CurtainPrompt.ShowError("GenericTryAgain".FromLanguageResource()); return null; } if (!App.Locator.Player.IsPlayerActive && clearIfNotActive) { await App.Locator.CollectionService.ClearQueueAsync(); } var insert = App.Locator.AppSettingsHelper.Read("AddToInsert", true, SettingsStrategy.Roaming) && !ignoreInsertMode; queueSong = await App.Locator.CollectionService.AddToQueueAsync( song, insert ? App.Locator.Player.CurrentQueue : null, shuffleInsert).ConfigureAwait(false); if (!App.Locator.Player.IsPlayerActive && playIfNotActive) { App.Locator.AudioPlayerHelper.PlaySong(queueSong); DispatcherHelper.RunAsync(() => App.Locator.Player.CurrentQueue = queueSong); } handle.Data.Add("FinalCount", App.Locator.CollectionService.PlaybackQueue.Count.ToString()); } var overflow = App.Locator.CollectionService.CurrentPlaybackQueue.Count - MaxPlayQueueCount; if (overflow > 0) { for (var i = 0; i < overflow; i++) { var queueToRemove = App.Locator.CollectionService.CurrentPlaybackQueue.FirstOrDefault(); if (queueToRemove == App.Locator.Player.CurrentQueue || queueToRemove == queueSong) { queueToRemove = App.Locator.CollectionService.CurrentPlaybackQueue[1]; } await App.Locator.CollectionService.DeleteFromQueueAsync(queueToRemove).ConfigureAwait(false); } } return queueSong; }
private static async Task MatchSongAsync(Song song) { using (var handler = Insights.TrackTime("Match Song")) { var variousArtist = song.Artist.Name == "Various Artists"; var url = await App.Locator.Mp3MatchEngine.FindMp3For(song.Name, variousArtist ? song.ArtistName : song.Artist.Name).ConfigureAwait(false); if (string.IsNullOrEmpty(url) && !variousArtist && song.ArtistName != song.Artist.Name) { // try using the song artist name when is different than the album artist name url = await App.Locator.Mp3MatchEngine.FindMp3For(song.Name, song.ArtistName).ConfigureAwait(false); } var matched = !string.IsNullOrEmpty(url); handler.Data.Add("FoundMatch", matched ? "True" : "False"); await App.Locator.PclDispatcherHelper.RunAsync( () => { if (string.IsNullOrEmpty(url)) { song.SongState = SongState.NoMatch; } else { song.AudioUrl = url; song.SongState = SongState.None; } }); await App.Locator.SqlService.UpdateItemAsync(song); EasyTracker.GetTracker().SendEvent("Match Engine", "Match Song", "Found", matched ? 1 : 0); } }
public Task AddSongAsync(Song song, Tag tags) { throw new NotImplementedException(); }
public async Task<QueueSong> AddToQueueAsync(Song song, QueueSong position = null, bool shuffleInsert = true) { if (song == null) { return null; } var rnd = new Random(DateTime.Now.Millisecond); QueueSong prev = null; QueueSong shufflePrev = null; QueueSong next = null; QueueSong shuffleNext = null; var shuffleIndex = -1; var normalIndex = -1; if (position != null) { shuffleIndex = ShufflePlaybackQueue.IndexOf(position) + 1; normalIndex = PlaybackQueue.IndexOf(position) + 1; } var insert = normalIndex > -1 && normalIndex < PlaybackQueue.Count; var insertShuffle = shuffleIndex > -1 && shuffleInsert; var shuffleLastAdd = shuffleIndex == ShufflePlaybackQueue.Count; if (insert) { next = PlaybackQueue.ElementAtOrDefault(normalIndex); if (next != null) { _lookupMap.TryGetValue(next.PrevId, out prev); } } else { prev = PlaybackQueue.LastOrDefault(); } if (insertShuffle) { if (shuffleLastAdd) { shufflePrev = ShufflePlaybackQueue.ElementAtOrDefault(ShufflePlaybackQueue.Count - 1); } else { shuffleNext = ShufflePlaybackQueue.ElementAtOrDefault(shuffleIndex); if (shuffleNext != null) { _lookupMap.TryGetValue(shuffleNext.ShufflePrevId, out shufflePrev); } } } else { if (ShufflePlaybackQueue.Count > 1) { shuffleIndex = rnd.Next(1, ShufflePlaybackQueue.Count - 1); shuffleNext = ShufflePlaybackQueue.ElementAt(shuffleIndex); _lookupMap.TryGetValue(shuffleNext.ShufflePrevId, out shufflePrev); } else { shuffleLastAdd = true; shufflePrev = prev; } } // Create the new queue entry var newQueue = new QueueSong { SongId = song.Id, NextId = next == null ? 0 : next.Id, PrevId = prev == null ? 0 : prev.Id, ShuffleNextId = shuffleNext == null ? 0 : shuffleNext.Id, ShufflePrevId = shufflePrev == null ? 0 : shufflePrev.Id, Song = song }; // Add it to the database await _bgSqlService.InsertAsync(newQueue).ConfigureAwait(false); if (next != null) { // Update the prev id of the queue that was replaced next.PrevId = newQueue.Id; await _bgSqlService.UpdateItemAsync(next).ConfigureAwait(false); } if (prev != null) { // Update the next id of the previous tail prev.NextId = newQueue.Id; await _bgSqlService.UpdateItemAsync(prev).ConfigureAwait(false); } if (shuffleNext != null) { shuffleNext.ShufflePrevId = newQueue.Id; await _bgSqlService.UpdateItemAsync(shuffleNext).ConfigureAwait(false); } if (shufflePrev != null) { shufflePrev.ShuffleNextId = newQueue.Id; await _bgSqlService.UpdateItemAsync(shufflePrev).ConfigureAwait(false); } // Add the new queue entry to the collection and map await _dispatcher.RunAsync( () => { if (insert) { try { PlaybackQueue.Insert(normalIndex, newQueue); } catch (ArgumentOutOfRangeException) { PlaybackQueue.Add(newQueue); } } else { PlaybackQueue.Add(newQueue); } if (shuffleLastAdd || !shuffleInsert) { ShufflePlaybackQueue.Add(newQueue); } else { try { ShufflePlaybackQueue.Insert(shuffleIndex, newQueue); } catch (ArgumentOutOfRangeException) { ShufflePlaybackQueue.Add(newQueue); } } }).ConfigureAwait(false); _lookupMap.TryAdd(newQueue.Id, newQueue); return newQueue; }
public Task DeleteSongAsync(Song song) { throw new NotImplementedException(); }
public Task<QueueSong> AddToQueueAsync(Song song, QueueSong position = null, bool shuffleInsert = true) { throw new NotImplementedException(); }
public Task AddToPlaylistAsync(Playlist playlist, Song song) { throw new NotImplementedException(); }
public async Task AddToPlaylistAsync(Playlist playlist, Song song) { var tail = playlist.Songs.LastOrDefault(); // Create the new queue entry var newSong = new PlaylistSong { SongId = song.Id, NextId = 0, PrevId = tail == null ? 0 : tail.Id, Song = song, PlaylistId = playlist.Id }; // Add it to the database await _sqlService.InsertAsync(newSong); if (tail != null) { // Update the next id of the previous tail tail.NextId = newSong.Id; await _sqlService.UpdateItemAsync(tail); } // Add the new queue entry to the collection and map playlist.Songs.Add(newSong); playlist.LookupMap.TryAdd(newSong.Id, newSong); }
/// <summary> /// Call internally to report a finished BackgroundDownload /// </summary> /// <param name="song"> /// The song that just finished downloading. /// </param> /// <returns> /// Task. /// </returns> private async Task DownloadFinishedForAsync(Song song) { var downloadOperation = (DownloadOperation) song.Download.DownloadOperation; await UpdateId3TagsAsync(song, downloadOperation.ResultFile); var filename = song.Name.CleanForFileName("Invalid Song Name"); if (song.ArtistName != song.Album.PrimaryArtist.Name) { filename = song.ArtistName.CleanForFileName("Invalid Artist Name") + "-" + filename; } var path = string.Format( AppConstant.SongPath, song.Album.PrimaryArtist.Name.CleanForFileName("Invalid Artist Name"), song.Album.Name.CleanForFileName("Invalid Album Name"), filename); var newDestination = await WinRtStorageHelper.CreateFileAsync(path, KnownFolders.MusicLibrary); downloadOperation.ResultFile.MoveAndReplaceAsync(newDestination); song.AudioUrl = newDestination.Path; song.SongState = SongState.Downloaded; song.DownloadId = null; await sqlService.UpdateItemAsync(song); }
public static async Task PlaySongsAsync(Song song, List<Song> songs, bool forceClear = false) { if (song == null || songs == null || songs.Count == 0) { return; } if (!song.IsMatched) { return; } songs = songs.Where(p => p.IsMatched).ToList(); if (songs.Count == 0) { CurtainPrompt.ShowError("The songs haven't been matched yet."); return; } var skip = songs.IndexOf(song); var ordered = songs.Skip(skip).ToList(); ordered.AddRange(songs.Take(skip)); var overflow = songs.Count - MaxMassPlayQueueCount; if (overflow > 0) { for (var i = 0; i < overflow; i++) { ordered.Remove(ordered.LastOrDefault()); } } var playbackQueue = App.Locator.CollectionService.PlaybackQueue.ToList(); var sameLength = _currentlyPreparing || songs.Count < playbackQueue.Count || playbackQueue.Count >= MaxMassPlayQueueCount; var containsSong = playbackQueue.FirstOrDefault(p => p.SongId == song.Id) != null; var createQueue = forceClear || (!sameLength || !containsSong); if (_currentlyPreparing && createQueue) { // cancel the previous _currentlyPreparing = false; // wait for it to stop await Task.Delay(50); } if (!createQueue) { App.Locator.AudioPlayerHelper.PlaySong(playbackQueue.First(p => p.SongId == song.Id)); } else { using (Insights.TrackTime("Create Queue", "Count", ordered.Count.ToString())) { _currentlyPreparing = true; try { await App.Locator.CollectionService.ClearQueueAsync().ConfigureAwait(false); } catch (SQLiteException) { // retry try { App.Locator.CollectionService.ClearQueueAsync().Wait(); } catch (SQLiteException) { // quit CurtainPrompt.ShowError( "Problem clearing the queue. You seem to be running low on storage."); return; } } var queueSong = await App.Locator.CollectionService.AddToQueueAsync(song).ConfigureAwait(false); App.Locator.AudioPlayerHelper.PlaySong(queueSong); App.Locator.SqlService.BeginTransaction(); for (var index = 1; index < ordered.Count; index++) { if (!_currentlyPreparing) { break; } var s = ordered[index]; await App.Locator.CollectionService.AddToQueueAsync(s).ConfigureAwait(false); } App.Locator.SqlService.Commit(); _currentlyPreparing = false; } } }
/// <summary> /// Updates the id3 tags. WARNING, there needs to be more testing with lower end devices. /// </summary> /// <param name="song">The song.</param> /// <param name="file">The file.</param> private async Task UpdateId3TagsAsync(Song song, IStorageFile file) { using (var fileStream = await file.OpenStreamForWriteAsync().ConfigureAwait(false)) { File tagFile; try { tagFile = File.Create(new SimpleFileAbstraction(file.Name, fileStream, fileStream)); } catch { // either the download is corrupted or is not an mp3 file return; } var newTags = tagFile.GetTag(TagTypes.Id3v2, true); newTags.Title = song.Name; if (song.Artist.ProviderId != "autc.unknown") { newTags.Performers = song.ArtistName.Split(',').Select(p => p.Trim()).ToArray(); } newTags.Album = song.Album.Name; newTags.AlbumArtists = new[] {song.Album.PrimaryArtist.Name}; if (!string.IsNullOrEmpty(song.Album.Genre)) { newTags.Genres = song.Album.Genre.Split(',').Select(p => p.Trim()).ToArray(); } newTags.Track = (uint) song.TrackNumber; newTags.Comment = "Downloaded with Audiotica - http://audiotica.fm"; try { if (song.Album.HasArtwork) { var albumFilePath = string.Format(AppConstant.ArtworkPath, song.Album.Id); var artworkFile = await StorageHelper.GetFileAsync(albumFilePath).ConfigureAwait(false); using (var artworkStream = await artworkFile.OpenAsync(FileAccess.Read)) { using (var memStream = new MemoryStream()) { await artworkStream.CopyToAsync(memStream); newTags.Pictures = new IPicture[] { new Picture( new ByteVector( memStream.ToArray(), (int) memStream.Length)) }; } } } } catch (UnauthorizedAccessException) { // Should never happen, since we are opening the files in read mode and nothing is locking it. } await Task.Run(() => tagFile.Save()); } }
public static void MatchSong(Song song) { TaskHelper.Enqueue(MatchSongAsync(song)); }
/// <summary> /// Hanbdles a single BackgroundDownload for a song. /// </summary> /// <param name="song"> /// The song to be downloaded /// </param> /// <param name="download"> /// The download operation /// </param> /// <param name="start"> /// Either the download is started or just handled /// </param> private async void HandleDownload(Song song, DownloadOperation download, bool start) { if (song == null || download == null) { return; } song.Download = new BackgroundDownload(download); ActiveDownloads.Add(song); try { var progressCallback = new Progress<DownloadOperation>(DownloadProgress); if (start) { // Start the BackgroundDownload and attach a progress handler. await download.StartAsync().AsTask(song.Download.CancellationTokenSrc.Token, progressCallback); } else { // The BackgroundDownload was already running when the application started, re-attach the progress handler. await download.AttachAsync().AsTask(song.Download.CancellationTokenSrc.Token, progressCallback); } // Download Completed var response = download.GetResponseInformation(); // Make sure it is success if (response.StatusCode < 400) { await DownloadFinishedForAsync(song); } else { song.SongState = SongState.None; sqlService.UpdateItem(song); download.ResultFile.DeleteAsync(); } } catch { song.SongState = SongState.None; sqlService.UpdateItem(song); download.ResultFile.DeleteAsync(); } finally { ActiveDownloads.Remove(song); } }
public async Task<bool> MatchSongAsync(Song song) { var match = await _audioticaService.GetMatchesAsync(song.Name, song.Artist.Name); if (!match.Success || match.Data.Count <= 0) return false; using (var sql = _sqlFunc()) { song.SongState = SongState.None; song.AudioUrl = match.Data[0].AudioUrl; await sql.UpdateItemAsync(song); } return true; }
public async Task StartDownloadAsync(Song song) { song.SongState = SongState.Downloading; try { var path = string.Format("songs/{0}.mp3", song.Id); var destinationFile = await WinRtStorageHelper.CreateFileAsync(path, ApplicationData.Current.LocalFolder, CreationCollisionOption.ReplaceExisting).ConfigureAwait(false); var downloader = new BackgroundDownloader(); var download = downloader.CreateDownload(new Uri(song.AudioUrl), destinationFile); download.Priority = BackgroundTransferPriority.High; song.DownloadId = download.Guid.ToString(); await sqlService.UpdateItemAsync(song).ConfigureAwait(false); dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => HandleDownload(song, download, true)); } catch (Exception e) { if (e.Message.Contains("there is not enough space on the disk")) { dispatcher.RunAsync( CoreDispatcherPriority.Normal, () => CurtainPrompt.ShowError("Not enough disk space to download.")); } dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => song.SongState = SongState.None); sqlService.UpdateItemAsync(song).ConfigureAwait(false); } }
public async Task UpdateQueueAsync() { using (var bg = _bgFunc()) { await bg.DeleteTableAsync<QueueSong>(); } using (var service = _sqlFunc()) { foreach (var radioSong in Songs) { var song = await service.SelectFirstAsync<Song>(p => p.ProviderId == "gn." + radioSong.Id); var artist = await service.SelectFirstAsync<Artist>( p => p.Name.ToLower() == radioSong.AlbumArtistName.ToLower()); var album = await service.SelectFirstAsync<Album>(p => p.Name.ToLower() == radioSong.AlbumName.ToLower()); // Already added if (song != null) { song.Artist = artist; song.Album = album; await AddToQueueAsync(song); continue; } song = new Song { Name = radioSong.Name, ArtistName = radioSong.ArtistName, IsTemp = true, RadioId = _dbId, TrackNumber = radioSong.TrackNumber, ProviderId = "gn." + radioSong.Id, SongState = SongState.BackgroundMatching, Album = new Album { Name = radioSong.AlbumName, ProviderId = "gn." + radioSong.AlbumId }, Artist = new Artist { Name = radioSong.AlbumArtistName, ProviderId = "gn.track." + radioSong.Id } }; if (artist == null) { await service.InsertAsync(song.Artist); song.ArtistId = song.Artist.Id; if (album != null) song.Album = album; song.Album.PrimaryArtistId = song.Artist.Id; song.Album.PrimaryArtist = song.Artist; } else { song.Artist = artist; song.ArtistId = artist.Id; } if (album == null) { await service.InsertAsync(song.Album); song.AlbumId = song.Album.Id; } else { song.Album = album; song.AlbumId = album.Id; } await service.InsertAsync(song); await AddToQueueAsync(song); } } }
private async void ReceiveSong(Song song) { CurrentSong = song; Mp3Truck = null; Mp3Clan = null; Meile = null; Netease = null; Mp3Skull = null; var tasks = new List<Task> { Task.Factory.StartNew( async () => { await dispatcherHelper.RunAsync(() => IsMp3TruckLoading = true); var results = await searchService.SearchMp3Truck(CurrentSong.Name, CurrentSong.Artist.Name, checkAllLinks: true); await dispatcherHelper.RunAsync( () => { IsMp3TruckLoading = false; if (results == null) { return; } Mp3Truck = new ObservableCollection<WebSong>(results); }); }), Task.Factory.StartNew( async () => { await dispatcherHelper.RunAsync(() => IsMp3ClanLoading = true); var results = await searchService.SearchMp3Clan( CurrentSong.Name, CurrentSong.Artist.Name, limit: 25, checkAllLinks: true); await dispatcherHelper.RunAsync( () => { IsMp3ClanLoading = false; if (results == null) { return; } Mp3Clan = new ObservableCollection<WebSong>(results); }); }), Task.Factory.StartNew( async () => { await dispatcherHelper.RunAsync(() => IsNeteaseLoading = true); var results = await searchService.SearchNetease( CurrentSong.Name, CurrentSong.Artist.Name, limit: 25, checkAllLinks: true); await dispatcherHelper.RunAsync( () => { IsNeteaseLoading = false; if (results == null) { return; } Netease = new ObservableCollection<WebSong>(results); }); }), Task.Factory.StartNew( async () => { await dispatcherHelper.RunAsync(() => IsMeileLoading = true); var results = await searchService.SearchMeile( CurrentSong.Name, CurrentSong.Artist.Name, limit: 25, checkAllLinks: true); await dispatcherHelper.RunAsync( () => { IsMeileLoading = false; if (results == null) { return; } Meile = new ObservableCollection<WebSong>(results); }); }), Task.Factory.StartNew( async () => { await dispatcherHelper.RunAsync(() => IsMp3SkullLoading = true); var results = await searchService.SearchMp3Skull(CurrentSong.Name, CurrentSong.Artist.Name, checkAllLinks: true); await dispatcherHelper.RunAsync( () => { IsMp3SkullLoading = false; if (results == null) { return; } Mp3Skull = new ObservableCollection<WebSong>(results); }); }) }; await Task.WhenAll(tasks); }