public async Task <Uri> GetAlbumCover(string artist, string title)
{
var result = await _groove.SearchAsync(MediaNamespace.music, artist + " - " + title, filter : SearchFilter.Tracks, maxItems : 1);
var grooveArtist = result?.Artists?.Items.FirstOrDefault();
if (grooveArtist != null)
{
var imageUrl = grooveArtist.GetImageUrl();
if (!string.IsNullOrEmpty(imageUrl))
{
//check if image exists
var httpClient = new HttpClient();
var response = await httpClient.GetAsync(new Uri(imageUrl), HttpCompletionOption.ResponseHeadersRead);
if (response.IsSuccessStatusCode)
{
return(new Uri(imageUrl));
}
}
}
return(null);
}
public async Task SearchCatalogAsync(string searchQuery, string country)
{
ContentResponse searchResponse = await _grooveClient.SearchAsync(
MediaNamespace.music,
searchQuery,
ContentSource.Catalog,
maxItems : 10,
country : country);
_errorViewModel.HandleGrooveApiError(searchResponse.Error);
DisplayMusicContent(searchResponse);
}
public async Task HelpYouGetStarted()
{
// Start by registering an Application on the Groove API Program (see https://developer.microsoft.com/dashboard/groove)
// Create a client
IGrooveClient client = GrooveClientFactory.CreateGrooveClient(MicrosoftAppClientId, MicrosoftAppClientSecret);
// Use null to get your current geography.
// Specify a 2 letter country code (such as "US" or "DE") to force a specific country.
string country = null;
// Search for albums in your current geography
ContentResponse searchResponse = await client.SearchAsync(
MediaNamespace.music,
"Foo Fighters",
filter : SearchFilter.Albums,
maxItems : 5,
country : country);
Console.WriteLine($"Found {searchResponse.Albums.TotalItemCount} albums");
foreach (Album albumResult in searchResponse.Albums.Items)
{
Console.WriteLine(albumResult.Name);
}
// List tracks in the first album
Album album = searchResponse.Albums.Items[0];
ContentResponse lookupResponse = await client.LookupAsync(
album.Id,
extras : ExtraDetails.Tracks,
country : country);
// Display information about the album
album = lookupResponse.Albums.Items[0];
Console.WriteLine($"Album: {album.Name} (link: {album.GetLink(ContentExtensions.LinkAction.Play)}, " +
$"image: {album.GetImageUrl(800, 800)})");
foreach (Contributor contributor in album.Artists)
{
Artist artist = contributor.Artist;
Console.WriteLine($"Artist: {artist.Name} (link: {artist.GetLink()}, image: {artist.GetImageUrl(1920, 1080)})");
}
foreach (Track track in album.Tracks.Items)
{
Console.WriteLine($"Track: {track.TrackNumber} - {track.Name}");
}
}
private async Task <List <PlaylistAction> > GetPlaylistActions(List <MusicBeePlaylist> playlistsToSync, List <Playlist> existingGroovePlaylists)
{
List <PlaylistAction> playlistActions = new List <PlaylistAction>();
int totalPlaylistsProcessed = 0;
foreach (MusicBeePlaylist playlist in playlistsToSync)
{
_window.WriteOutputLine($"Preparing {playlist.Name} for sync");
// If playlist already exists,
// for now, delete playlist and remake completely
// eventually, calculate diff
Playlist matchingGroovePlaylist = existingGroovePlaylists.Where(p => p.Name == playlist.Name).FirstOrDefault();
if (matchingGroovePlaylist != null)
{
PlaylistAction deletePlaylist = new PlaylistAction()
{
Id = matchingGroovePlaylist.Id,
};
playlistActions.Add(deletePlaylist);
}
// Get list of file paths to tracks in music bee library
string[] playlistFiles = null;
if (_mbApiInterface.Playlist_QueryFiles(playlist.MusicBeeName))
{
bool success = _mbApiInterface.Playlist_QueryFilesEx(playlist.MusicBeeName, ref playlistFiles);
if (!success)
{
_window.WriteOutputLine($"Couldn't find playlist file for: {playlist.Name}");
return(null);
}
}
else
{
playlistFiles = new string[] { };
}
// Map the track in music bee to Groove
List <TrackAction> tracksToAdd = new List <TrackAction>();
foreach (string file in playlistFiles)
{
string title = _mbApiInterface.Library_GetFileTag(file, MetaDataType.TrackTitle);
string artist = _mbApiInterface.Library_GetFileTag(file, MetaDataType.Artist);
ContentResponse response = await _client.SearchAsync(MediaNamespace.music, HttpUtility.UrlEncode(title), ContentSource.Collection, SearchFilter.Tracks);
if (response.Error == null || response.Error.ErrorCode == Enum.GetName(typeof(ErrorCode), ErrorCode.COLLECTION_INVALID_DATA))
{
TrackAction action = null;
List <Track> tracksFound = response.Tracks.Items.Cast <Track>().ToList();
foreach (Track track in tracksFound)
{
if (track.Name == title &&
track.Artists.Where(c => c.Artist.Name == artist).FirstOrDefault() != null)
{
action = new TrackAction()
{
Action = TrackActionType.Add,
Id = track.Id
};
tracksToAdd.Add(action);
}
}
if (action == null)
{
_window.WriteOutputLine($"Could not match track {artist} - {title}");
}
}
else
{
_window.WriteOutputLine($"Could not match track {artist} - {title}");
}
}
PlaylistAction createPlaylist = new PlaylistAction()
{
Name = playlist.Name,
TrackActions = tracksToAdd
};
playlistActions.Add(createPlaylist);
totalPlaylistsProcessed++;
_window.UpdatePreparationProgress(100 * totalPlaylistsProcessed / playlistsToSync.Count);
}
return(playlistActions);
}
