public static async Task <SavingError> SaveSpotifyTrackLevel2(SimpleTrack track, FullAlbum album)
{
var result = await SaveSpotifyTrackLevel3(track, album);
ShowResults(result, track.Name);
return(result);
}
private object ListPlaylistTracksToListTracks(object data, IServiceProvider serviceProvider, Models.Account user)
{
List <PlaylistTrack> playlistTracks = data as List <PlaylistTrack>;
List <SimpleTrack> tracks = new List <SimpleTrack>();
SpotifyService service = (SpotifyService)serviceProvider.GetService(typeof(SpotifyService));
SpotifyWebAPI api = service.GetSpotifyWebApi(service.GetSpotifyToken(user));
Console.WriteLine("Adding tracks from playlist");
for (int i = 0; i < playlistTracks.Count; i++)
{
Console.WriteLine("Adding track " + playlistTracks[i].Track.Name);
SimpleTrack track = new SimpleTrack();
track.Artists = playlistTracks[i].Track.Artists;
track.AvailableMarkets = playlistTracks[i].Track.AvailableMarkets;
track.DiscNumber = playlistTracks[i].Track.DiscNumber;
track.DurationMs = playlistTracks[i].Track.DurationMs;
track.Error = playlistTracks[i].Track.Error;
track.Explicit = playlistTracks[i].Track.Explicit;
track.ExternUrls = playlistTracks[i].Track.ExternUrls;
track.Href = playlistTracks[i].Track.Href;
track.Id = playlistTracks[i].Track.Id;
track.Name = playlistTracks[i].Track.Name;
track.PreviewUrl = playlistTracks[i].Track.PreviewUrl;
track.Restrictions = playlistTracks[i].Track.Restrictions;
track.TrackNumber = playlistTracks[i].Track.TrackNumber;
track.Type = playlistTracks[i].Track.Type;
track.Uri = playlistTracks[i].Track.Uri;
tracks.Add(track);
}
return(tracks as object);
}
public void downloadPreview(SimpleTrack track)
{
filename = AppContext.BaseDirectory + "spotify\\" + track.Name + ".mp3";
preview = track;
if (File.Exists(filename))
{
return;
}
try
{
using (var client = new WebClient())
{
client.DownloadFile(track.PreviewUrl + ".mp3", filename);
}
}
catch (System.Net.WebException e)
{
if (e.Status == WebExceptionStatus.ProtocolError)
{
MessageBox.Show("Spotify messed up");
}
}
}
public SpotifyTrackInfo(SimpleTrack simpleTrack)
{
this.Artists = simpleTrack.Artists;
this.AvailableMarkets = simpleTrack.AvailableMarkets;
this.DiscNumber = simpleTrack.DiscNumber;
this.Duration = TimeSpan.FromMilliseconds(simpleTrack.DurationMs);
this.Explicit = simpleTrack.Explicit;
this.ExternUrls = new Dictionary <string, Uri>(
simpleTrack.ExternUrls
.Select(pair => new KeyValuePair <string, Uri>(pair.Key, new Uri(pair.Value)))); // Convert value to URI
this.Id = simpleTrack.Id;
this.Name = simpleTrack.Name;
this.PreviewUrl = simpleTrack.PreviewUrl;
this.TrackNumber = simpleTrack.TrackNumber;
this.Type = simpleTrack.Type;
try
{
this.Uri = this.ExternUrls["spotify"];
}
catch (KeyNotFoundException) // Should never fail
{
// Convert Spotify URI to a track link (wont link track to playlist or album if it was linked)
this.Uri = new Uri($"https://open.spotify.com/track/{this.Id}");
}
}
public string GetArtistName(SimpleTrack track)
{
string result = string.Empty;
foreach (var artist in track.Artists)
{
result += artist.Name + ", ";
}
return(result);
}
public VideoMetadata(SimpleTrack spotifyTrack)
{
string artist = spotifyTrack.Artists.FirstOrDefault()?.Name;
LookupTitleOnYoutube = true;
Title = string.IsNullOrWhiteSpace(artist) ? spotifyTrack.Name : $"{artist} - {spotifyTrack.Name}";
Uploader = "Spotify";
WebpageUrl = "https://open.spotify.com/track/" + spotifyTrack.Id;
Extractor = "spotify";
Duration = spotifyTrack.DurationMs / 1000;
}
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 static TrackViewModel FromSimpleTrack(SimpleTrack track, DateTime?playedAt = null)
{
var authorNames = track.Artists.Select(a => a.Name);
return(new TrackViewModel
{
Id = track.Id,
Name = track.Name,
Author = string.Join(", ", authorNames),
Album = track.Type, /// а где альбом
PlayedAt = playedAt,
});
}
private static async Task <SaveResults> SaveSpotifyTrackLevel4(SimpleTrack track, FullAlbum album)
{
try
{
if (track == null)
{
return new SaveResults()
{
Error = SavingError.Unknown
}
}
;
var preparedSong = track.ToSong();
if (App.Locator.CollectionService.SongAlreadyExists(track.Name, album.Name, album.Artist != null ? album.Artist.Name : track.Artist.Name))
{
return new SaveResults()
{
Error = SavingError.AlreadyExists
}
}
;
var fullTrack = track as FullTrack ?? await App.Locator.Spotify.GetTrack(track.Id);
var artist = fullTrack != null ? fullTrack.Artist : ((track.Artist != null) ? track.Artist : new SimpleArtist {
Name = "Unknown Artist"
});
preparedSong.ArtistName = fullTrack != null ? fullTrack.Artist.Name : artist.Name;
preparedSong.Album = album.ToAlbum();
preparedSong.Artist = fullTrack != null ? (new Data.Collection.Model.Artist {
Name = preparedSong.ArtistName.Trim().Replace(" ", ""), ProviderId = "spotify." + album.Artist.Id
}) : album.Artist.ToArtist();
preparedSong.Album.PrimaryArtist = preparedSong.Artist;
await App.Locator.CollectionService.AddSongAsync(preparedSong).ConfigureAwait(false);
CollectionHelper.MatchSong(preparedSong);
return(new SaveResults()
{
Error = SavingError.None, Song = preparedSong
});
}
catch
{
return(new SaveResults()
{
Error = SavingError.Unknown
});
}
}
private WebSong CreateSong(SimpleTrack track)
{
var song = new WebSong(GetType())
{
Title = track.Name,
Token = track.Id,
IsPartial = true,
TrackNumber = (uint)track.TrackNumber,
DiskNumber = (uint)track.DiscNumber
};
var full = track as FullTrack;
if (full != null)
{
song.IsPartial = false;
if (full.Artists != null)
{
song.Artists = full.Artists.Select(CreateArtist).ToList();
}
else
{
song.IsPartial = true;
}
if (full.Album != null)
{
song.Album = CreateAlbum(full.Album);
}
else
{
song.IsPartial = true;
}
}
else
{
if (track.Artist != null)
{
song.Artists = new List <WebArtist> {
CreateArtist(track.Artist)
}
}
;
}
return(song);
}
private static async Task <List <TrackArtist> > MapTrackArtistsAsync(
SimpleTrack track,
HashSet <string> albumArtistsSpotifyIds,
IEnumerable <Artist> albumArtists,
IRepositoryManager repositoryManager,
IMapper mapper,
SpotifyAPICredentials spotifyAPICredentials)
{
List <TrackArtist> trackArtists = new List <TrackArtist>();
List <string> trackArtistsToBeCreated = new List <string>();
var trackArtistSpotifyIds = track.Artists.Select(a => a.Id).ToHashSet();
foreach (var trackArtist in track.Artists)
{
if (albumArtistsSpotifyIds.Contains(trackArtist.Id))
{
var albumArtist = albumArtists.Where(a => a.SpotifyId == trackArtist.Id).FirstOrDefault();
trackArtists.Add(new TrackArtist
{
ArtistId = albumArtist.Id,
CreatedOn = DateTime.Now,
LastUpdatedOn = DateTime.Now
});
}
else
{
trackArtistsToBeCreated.Add(trackArtist.Id);
}
}
if (trackArtistsToBeCreated.Count > 0)
{
var newArtists = await ArtistModel.FetchArtistsAsync(trackArtistsToBeCreated, spotifyAPICredentials);
var artists = await ArtistModel.CreateOrFetchArtistAsync(newArtists, repositoryManager, mapper);
trackArtists.AddRange(MapArtistsToTrackArtists(artists.Select(a => a.Id).ToList()));
}
return(trackArtists);
}
public static WebSong CreateSong(SimpleTrack track)
{
var song = new WebSong()
{
Name = track.Name,
Id = track.Id,
};
if (track.Artist != null)
{
song.Artist = !string.IsNullOrEmpty(track.Artist.Name) ? track.Artist.Name : "Unknown Artist";
}
else
{
song.Artist = "Unknown Artist";
}
return(song);
}
public void getAlbumInfo(Action <string> callback)
{
var currentAlbum = _spotify.GetAlbumTracks(lastLoadedID);
if (currentAlbum.HasError())
{
callback("Something went wrong GetAlbumTracks");
return;
}
FullTrack track = getCurrentSong();
string ret = "Playing Album:";
int count = currentAlbum.Items.Count;
for (int i = 0; i < count; i++)
{
SimpleTrack item = currentAlbum.Items[i];
ret += "\n";
if (track.Id == item.Id)
{
ret += "* ";
}
ret += getArtistsString(item.Artists) + " - " + item.Name;
if (count < maxItemsList && i + 1 == count)
{
callback(ret);
}
else if (i != 0 && i % maxItemsList == 0)
{
callback(ret);
ret = "";
}
}
}
public static async Task SaveSpotifyTrackLevel2(SimpleTrack track, FullAlbum album)
{
if (!App.Locator.Setting.IsLoggedIn)
{
if (_warningCount > 0)
{
ToastManager.ShowError("Login required.");
return;
}
await MessageHelpers.LoginRequired();
_warningCount += 1;
}
var fTrack = track;
App.Locator.PBar.IsEnable = true;
try
{
track.Name = track.Name.GetSongNameFromMain();
track.Artist.Name = track.Artist.Name.GetArtistName();
if (track.Name == "Unknown Track")
{
track.Name = fTrack.Name;
}
if (track.Artist.Name == "Unknown Artist" && fTrack.Artist.Name != "Unknown Artist")
{
track.Artist.Name = fTrack.Artist.Name;
}
await SpotifySavingHelper.SaveSpotifyTrackLevel2(track, album);
}
catch
{
await SpotifySavingHelper.SaveSpotifyTrackLevel2(track, album);
}
App.Locator.PBar.IsEnable = false;
}
/// <summary>
/// Displays the last song played from Spotify
/// </summary>
/// <param name="chatter">User that sent the message</param>
public static async Task <string> SpotifyLastPlayedSongAsync(TwitchChatter chatter, SpotifyWebClient spotify)
{
SimpleTrack simpleTrack = await spotify.GetLastPlayedSongAsync();
if (simpleTrack != null)
{
string artistName = "";
foreach (SimpleArtist simpleArtist in simpleTrack.Artists)
{
artistName += $"{simpleArtist.Name}, ";
}
artistName = artistName.ReplaceLastOccurrence(", ", "");
return($"@{chatter.DisplayName} <-- Last played from Spotify: \"{simpleTrack.Name}\" by {artistName} "
+ "https://open.spotify.com/track/" + simpleTrack.Id + " WARNING: This is currently a feature in BETA --> "
+ "https://developer.spotify.com/documentation/web-api/reference/player/get-recently-played/");
}
else
{
return($"Nothing was played recently @{chatter.DisplayName}");
}
}
public static void ProcessDirectory(SpotifyWebAPI api, DirectoryInfo dir, int depth)
{
if (depth != 0)
{
depth--;
foreach (DirectoryInfo di in dir.GetDirectories())
{
ProcessDirectory(api, di, depth);
}
return;
}
string path = dir.FullName;
string[] paths = path.Split(new char[] { Path.DirectorySeparatorChar });
string artistName = paths[paths.Length - 2];
string albumName = paths[paths.Length - 1];
Console.WriteLine($"Searching for {artistName} - {albumName}");
List <KeyValuePair <FullAlbum, FullArtist> > albums = new List <KeyValuePair <FullAlbum, FullArtist> >();
var search = GetArtistSearch(api, artistName);
bool hasExactMatch = false;
bool hasQualifyingMatch = false;
foreach (FullArtist a in search.Artists.Items)
{
List <SimpleAlbum> searchAlbums = GetArtistAlbums(api, a.Id);
if (searchAlbums == null)
{
continue;
}
foreach (SimpleAlbum album in searchAlbums)
{
if (a.Name.Equals(artistName, StringComparison.InvariantCultureIgnoreCase) &&
album.Name.Equals(albumName, StringComparison.InvariantCultureIgnoreCase))
{
hasExactMatch = true;
break;
}
else if (
(artistName.StartsWith(a.Name, StringComparison.InvariantCultureIgnoreCase) || a.Name.StartsWith(artistName, StringComparison.InvariantCultureIgnoreCase)) &&
(albumName.StartsWith(album.Name, StringComparison.InvariantCultureIgnoreCase) || album.Name.StartsWith(albumName, StringComparison.InvariantCultureIgnoreCase)))
{
hasQualifyingMatch = true;
}
}
foreach (SimpleAlbum album in searchAlbums)
{
bool exactMatch =
a.Name.Equals(artistName, StringComparison.InvariantCultureIgnoreCase) &&
album.Name.Equals(albumName, StringComparison.InvariantCultureIgnoreCase);
bool qualifyingMatch =
(artistName.StartsWith(a.Name, StringComparison.InvariantCultureIgnoreCase) || a.Name.StartsWith(artistName, StringComparison.InvariantCultureIgnoreCase)) &&
(albumName.StartsWith(album.Name, StringComparison.InvariantCultureIgnoreCase) || album.Name.StartsWith(albumName, StringComparison.InvariantCultureIgnoreCase));
if (hasExactMatch)
{
if (!exactMatch)
{
continue;
}
Console.WriteLine("Exact Match");
}
else if (hasQualifyingMatch)
{
if (!qualifyingMatch)
{
continue;
}
Console.WriteLine("Qualifying Match");
}
Console.WriteLine($"#{albums.Count + 1} - {a.Name} - \"{album.Name}\" - {album.ReleaseDate} - {album.Type}");
FullAlbum fullAlbum = GetFullAlbum(api, album.Id);
albums.Add(new KeyValuePair <FullAlbum, FullArtist>(fullAlbum, a));
foreach (SimpleTrack track in fullAlbum.Tracks.Items)
{
Console.WriteLine($" D:{track.DiscNumber} T:{track.TrackNumber} - {track.Name}, MS:{track.DurationMs}");
}
}
}
FullAlbum selectedAlbum = null;
FullArtist selectedArtist = null;
if (albums.Count > 0)
{
Console.WriteLine("Type album number to accept album info");
if (int.TryParse(Console.ReadLine(), out int id) && id > 0 && id <= albums.Count)
{
selectedAlbum = albums[id - 1].Key;
selectedArtist = albums[id - 1].Value;
}
}
if (selectedAlbum != null)
{
string pictureFile = null;
if (selectedAlbum.Images.Count > 0)
{
Console.WriteLine("Downloading album images");
List <string> sizes = new List <string>()
{
"Small",
"Large"
};
foreach (string size in sizes)
{
Image i = selectedAlbum.Images.OrderBy(im => im.Height).FirstOrDefault(
im => size == "Small" ? im.Height <= 300 && im.Height > 64 : im.Height > 300);
if (i != null)
{
try
{
using (WebClient webClient = new WebClient())
{
string name = "AlbumArt_" + size + ".jpg";
if (File.Exists(Path.Combine(path, name)))
{
File.Delete(Path.Combine(path, name));
}
webClient.DownloadFile(i.Url, Path.Combine(path, name));
if (pictureFile == null)
{
pictureFile = Path.Combine(path, name);
}
}
}
catch (Exception e)
{
Console.WriteLine("Error saving thumbnail: " + e.Message);
}
}
}
}
int index = -1;
foreach (string file in Directory.EnumerateFiles(path, "*.mp3").OrderBy(f => f).ToList())
{
if (selectedAlbum.Tracks.Items.Count > ++index)
{
SimpleTrack track = selectedAlbum.Tracks.Items[index];
string safeName = track.Name + ".mp3";
foreach (char c in Path.GetInvalidFileNameChars())
{
safeName = safeName.Replace(c, '_');
}
string moveTo = Path.Combine(Path.GetDirectoryName(file), $"{track.TrackNumber:00} {safeName}");
Console.WriteLine($"Updating {Path.GetFileName(file)} to {Path.GetFileName(moveTo)}");
try
{
File.Move(file, moveTo);
}
catch (Exception e)
{
Console.WriteLine($"Error: {e.Message}");
}
TagLib.File tagFile = TagLib.File.Create(moveTo);
tagFile.Tag.Title = track.Name;
tagFile.Tag.Performers = track.Artists.Select(a => a.Name).ToArray();
tagFile.Tag.AlbumArtists = new string[] { artistName };
tagFile.Tag.Album = selectedAlbum.Name;
tagFile.Tag.Track = (uint)track.TrackNumber;
tagFile.Tag.Disc = (uint)track.DiscNumber;
if (DateTime.TryParse(selectedAlbum.ReleaseDate, out DateTime release))
{
tagFile.Tag.Year = (uint)release.Year;
}
tagFile.Tag.Genres = selectedAlbum.Genres.ToArray();
tagFile.Tag.Copyright = string.Join(", ", selectedAlbum.Copyrights.Select(c => $"{c.Type} - {c.Text}"));
if (pictureFile != null)
{
tagFile.Tag.Pictures = new TagLib.IPicture[] { new TagLib.Picture(pictureFile) };
}
tagFile.Save();
}
else
{
Console.WriteLine($"{Path.GetFileName(file)} not in track listing");
}
}
Console.WriteLine($"{artistName} - {albumName} Complete");
Console.WriteLine("-------------------------------------");
Console.WriteLine();
//Console.Clear();
}
}
private static async Task <SavingError> SaveSpotifyTrackLevel3(SimpleTrack track, FullAlbum album, bool onFinishDownloadArtwork = true)
{
//album = Cleanup(album);
// track = Cleanup(track);
if (track == null || album == null)
{
return(SavingError.Unknown);
}
var alreadySaving = SpotifySavingTracks.FirstOrDefault(p => p == track.Id) != null;
if (alreadySaving)
{
return(SavingError.AlreadySaving);
}
//adding id(alway unique) of track to list to avoid duplicate things.
SpotifySavingTracks.Add(track.Id);
while (!App.Locator.CollectionService.IsLibraryLoaded)
{
}
var startTransaction = !App.Locator.SqlService.DbConnection.IsInTransaction;
if (startTransaction)
{
App.Locator.SqlService.BeginTransaction();
}
var result = await SaveSpotifyTrackLevel4(track, album);
if (startTransaction)
{
App.Locator.SqlService.Commit();
}
// ShowResults(result.Error, track.Name);
SpotifySavingTracks.Remove(track.Id);
if (!onFinishDownloadArtwork)
{
return(result.Error);
}
if (result.Song != null)
{
if (!result.Song.Album.HasArtwork && !result.Song.Album.NoArtworkFound)
{
await DownloadArtworks.SaveAlbumImageAsync(result.Song.Album, album.Images[0].Url);
}
if (App.Locator.Setting.SpotifyArtworkSync)
{
await DownloadArtworks.DownloadArtistsArtworkAsyncFromSpotify(false, result.Song.Artist.Name);
}
else
{
await DownloadArtworks.DownloadArtistsArtworkAsync(false, result.Song.Artist.Name);
}
}
return(result.Error);
}
public static SpotifyTrack Convert(SimpleTrack spotifyTrack) => new()
private void CheckInput(object source, EventArgs e)
{
seeking = lcd.IsButtonPressed(LogiLcd.LcdButton.Mono2);
inControlMenu = lcd.IsButtonPressed(LogiLcd.LcdButton.Mono3);
if (inControlMenu && !seeking)
{
bool btn2InCtlNow = lcd.IsButtonPressed(LogiLcd.LcdButton.Mono2);
if (btn2InCtlNow && !btn2Before)
{
var error = api.PausePlayback();
if (error.HasError())
{
showingError = true;
errorString = error.Error.Message;
hideErrorTimer = new Timer();
hideErrorTimer.Enabled = true;
hideErrorTimer.Interval = 3000;
hideErrorTimer.Tick += OnErrorHidden;
}
}
btn2Before = btn2InCtlNow;
bool btn1InCtlNow = lcd.IsButtonPressed(LogiLcd.LcdButton.Mono1);
if (btn1InCtlNow && !btn1Before)
{
var error = api.SkipPlaybackToNext();
if (error.HasError())
{
showingError = true;
errorString = error.Error.Message;
hideErrorTimer = new Timer();
hideErrorTimer.Enabled = true;
hideErrorTimer.Interval = 3000;
hideErrorTimer.Tick += OnErrorHidden;
}
}
btn1Before = btn1InCtlNow;
bool btn0InCtlNow = lcd.IsButtonPressed(LogiLcd.LcdButton.Mono0);
if (btn0InCtlNow && !btn0Before)
{
var error = api.SkipPlaybackToPrevious();
if (error.HasError())
{
showingError = true;
errorString = error.Error.Message;
hideErrorTimer = new Timer();
hideErrorTimer.Enabled = true;
hideErrorTimer.Interval = 3000;
hideErrorTimer.Tick += OnErrorHidden;
}
}
btn0Before = btn0InCtlNow;
return;
}
if (seeking && !btn2Before && cachedPlayback != null && cachedPlayback.CurrentlyPlayingType != TrackType.Ad)
{
// set seek position to current
currentSeekPosition = (double)cachedPlayback.ProgressMs / cachedPlayback.Item.DurationMs;
}
btn2Before = seeking;
if (seeking)
{
bool btn0InSeekNow = lcd.IsButtonPressed(LogiLcd.LcdButton.Mono0);
if (btn0InSeekNow && !btn0Before)
{
int toMs = (int)(currentSeekPosition * cachedPlayback.Item.DurationMs);
var error = api.SeekPlayback(toMs);
if (error.HasError())
{
showingError = true;
errorString = error.Error.Message;
hideErrorTimer = new Timer();
hideErrorTimer.Enabled = true;
hideErrorTimer.Interval = 3000;
hideErrorTimer.Tick += OnErrorHidden;
}
seeking = false;
btn0Before = true;
return;
}
btn0Before = btn0InSeekNow;
if (lcd.IsButtonPressed(LogiLcd.LcdButton.Mono1))
{
currentSeekPosition -= seekSpeed;
}
if (lcd.IsButtonPressed(LogiLcd.LcdButton.Mono3))
{
currentSeekPosition += seekSpeed;
}
if (currentSeekPosition > 1.0)
{
currentSeekPosition = 1.0;
}
else if (currentSeekPosition < 0.0)
{
currentSeekPosition = 0.0;
}
return;
}
bool btn0Now = lcd.IsButtonPressed(LogiLcd.LcdButton.Mono0);
if (btn0Now && !btn0Before)
{
var thisItem = cachedPlayback;
if (thisItem == null || thisItem.Item == null)
{
return;
}
if (likedSongNotification || unlikedSongNotification)
{
likedSongNotification = unlikedSongNotification = false;
btn0Before = btn0Now;
disableLikedSongNotificationTimer.Enabled = false;
return;
}
var ListedItem = new List <string>(1);
likedOrUnlikedSong = thisItem.Item;
ListedItem.Add(likedOrUnlikedSong.Id);
if (cachedLikedTrack)
{
api.RemoveSavedTracks(ListedItem);
likedSongNotification = false;
unlikedSongNotification = true;
}
else
{
api.SaveTrack(likedOrUnlikedSong.Id);
likedSongNotification = true;
unlikedSongNotification = false;
}
disableLikedSongNotificationTimer = new Timer();
disableLikedSongNotificationTimer.Enabled = true;
disableLikedSongNotificationTimer.Interval = 5000;
disableLikedSongNotificationTimer.Tick += OnLikedSongNotificationFinished;
}
btn0Before = btn0Now;
bool btn1Now = lcd.IsButtonPressed(LogiLcd.LcdButton.Mono1);
if (btn1Now)
{
var playback = cachedPlayback;
if (playback == null)
{
return;
}
if (playback.CurrentlyPlayingType == TrackType.Ad)
{ // doing calls later down here is bad
return;
}
if (playback.Context == null)
{
}
else if (playback.Context.Type == "playlist")
{
var playlist = cachedPlaylist;
if (playlist == null)
{
return;
}
upNextPlaylistTrack = null;
for (int i = 0; i < playlist.Tracks.Items.Count; i++)
{
if (playlist.Tracks.Items[i].Track.Uri == playback.Item.Uri)
{
// next track is it
if (i == playlist.Tracks.Items.Count - 1)
{
upNextPlaylistTrack = playlist.Tracks.Items[0];
}
else
{
upNextPlaylistTrack = playlist.Tracks.Items[i + 1];
}
break;
}
}
if (upNextPlaylistTrack == null)
{
return;
}
}
else if (playback.Context.Type == "album")
{
upNextPlaylistTrack = null;
var newAlbum = cachedAlbum;
if (newAlbum == null)
{
return;
}
for (int i = 0; i < newAlbum.Tracks.Items.Count; i++)
{
if (playback.Item.Uri == newAlbum.Tracks.Items[i].Uri)
{
if (i == newAlbum.Tracks.Items.Count - 1)
{
upNextAlbumTrack = null;
}
else
{
upNextAlbumTrack = newAlbum.Tracks.Items[i + 1];
}
}
}
}
}
showUpNext = btn1Now;
}
private string GetTrackPreviewButtonString(SimpleTrack track)
{
return(string.IsNullOrEmpty(track.PreviewUrl)
? "🔇"
: $"[▶]({track.PreviewUrl})");
}
public SpotifyPreview(MediaPlayer mediaPlayer, SimpleTrack track)
{
player = mediaPlayer;
downloadPreview(track);
playPreview();
}
public static string GetTrackUrl(this SimpleTrack track)
{
return($"{SpotifyBaseUrl}/track/{track.Id}");
}
public static async Task <SaveResults> SaveTrackAsync(SimpleTrack track, FullAlbum album)
{
try
{
if (track == null || album == null)
{
return(new SaveResults()
{
Error = SavingError.Unknown
});
}
var preparedSong = track.ToSong();
var exists = App.Locator.CollectionService.SongAlreadyExists(
preparedSong.ProviderId,
track.Name,
album.Name,
album.Artist != null ? album.Artist.Name : track.Artist.Name);
if (exists != null)
{
return(new SaveResults {
Error = SavingError.AlreadyExists, Entry = exists
});
}
var fullTrack = track as FullTrack ?? await App.Locator.Spotify.GetTrack(track.Id);
var artist = fullTrack != null ? fullTrack.Artist : track.Artist;
preparedSong.ArtistName = fullTrack != null
? string.Join(", ", fullTrack.Artists.Select(p => p.Name))
: artist.Name;
preparedSong.Album = album.ToAlbum();
preparedSong.Artist = album.Artist.ToArtist();
preparedSong.Album.PrimaryArtist = preparedSong.Artist;
await App.Locator.CollectionService.AddSongAsync(preparedSong).ConfigureAwait(false);
CollectionHelper.MatchSong(preparedSong);
return(new SaveResults()
{
Error = SavingError.None, Entry = preparedSong
});
}
catch (NetworkException)
{
return(new SaveResults()
{
Error = SavingError.Network
});
}
catch
{
return(new SaveResults()
{
Error = SavingError.Unknown
});
}
}
