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