public async Task<WebResults> GetArtistTopSongsAsync(string artistToken, int limit = 50, string pageToken = null)
        {
            var response =
                await (pageToken == null
                    ? _client.SubBrowseAsync(artistToken, ContentSource.Catalog, BrowseItemType.Artist,
                        ExtraDetails.TopTracks, maxItems: limit)
                    : _client.SubBrowseContinuationAsync(artistToken, ContentSource.Catalog, BrowseItemType.Artist,
                        ExtraDetails.TopTracks, pageToken));

            var xboxArtist = response.Artists.Items.FirstOrDefault();

            if (response.Error == null)
            {
                var results = new WebResults
                {
                    HasMore = xboxArtist.TopTracks?.ContinuationToken != null,
                    PageToken = xboxArtist.TopTracks?.ContinuationToken,
                    Songs = xboxArtist.TopTracks?.Items?.Select(CreateSong).ToList()
                };
                return results;
            }

            throw new ProviderException(response.Error.Message);
        }
 public override async Task<WebResults> SearchAsync(string query,
     WebResults.Type searchType = WebResults.Type.Song,
     int limit = 20, string pageToken = null)
 {
     switch (searchType)
     {
         default:
             var songResponse = await
                 (pageToken == null
                     ? _client.SearchAsync(Namespace.music, query, ContentSource.Catalog, SearchFilter.Tracks,
                         maxItems: limit)
                     : _client.SearchContinuationAsync(Namespace.music, pageToken));
             var songResults = new WebResults
             {
                 HasMore = songResponse.Tracks?.ContinuationToken != null,
                 PageToken = songResponse.Tracks?.ContinuationToken,
                 Songs = songResponse.Tracks?.Items?.Select(CreateSong).ToList()
             };
             return songResults;
         case WebResults.Type.Artist:
             var artistResponse =
                 await
                     (pageToken == null
                         ? _client.SearchAsync(Namespace.music, query, ContentSource.Catalog,
                             SearchFilter.Artists, maxItems: limit)
                         : _client.SearchContinuationAsync(Namespace.music, pageToken));
             var artistResults = new WebResults
             {
                 HasMore = artistResponse.Artists?.ContinuationToken != null,
                 PageToken = artistResponse.Artists?.ContinuationToken,
                 Artists = artistResponse.Artists?.Items?.Select(CreateArtist).ToList()
             };
             return artistResults;
         case WebResults.Type.Album:
             var albumResponse =
                 await
                     (pageToken == null
                         ? _client.SearchAsync(Namespace.music, query, ContentSource.Catalog, SearchFilter.Albums,
                             maxItems: limit)
                         : _client.SearchContinuationAsync(Namespace.music, pageToken));
             var albumResults = new WebResults
             {
                 HasMore = albumResponse.Albums?.ContinuationToken != null,
                 PageToken = albumResponse.Albums?.ContinuationToken,
                 Albums =
                     albumResponse.Albums?.Items?.Select(CreateAlbum).Distinct(new WebAlbum.Comparer()).ToList()
             };
             return albumResults;
     }
 }
 public abstract Task<WebResults> SearchAsync(string query, WebResults.Type searchType = WebResults.Type.Song,
     int limit = 20, string pageToken = null);
        public async Task<WebResults> GetArtistNewAlbumsAsync(string artistToken, int limit = 50,
           string pageToken = null)
        {
            var response =
                await (pageToken == null
                    ? _client.SubBrowseAsync(artistToken, ContentSource.Catalog, BrowseItemType.Artist,
                        ExtraDetails.Albums, OrderBy.ReleaseDate, limit)
                    : _client.SubBrowseContinuationAsync(artistToken, ContentSource.Catalog, BrowseItemType.Artist,
                        ExtraDetails.Albums, pageToken));
            var xboxArtist = response.Artists.Items.FirstOrDefault();

            if (response.Error == null)
            {
                var results = new WebResults
                {
                    HasMore = xboxArtist.Albums?.ContinuationToken != null,
                    PageToken = xboxArtist.Albums?.ContinuationToken,
                    Albums = xboxArtist.Albums?.Items?.Select(CreateAlbum).Distinct(new WebAlbum.Comparer()).ToList()
                };
                return results;
            }

            throw new ProviderException(response.Error.Message);
        }
 public Task<WebResults> SearchAsync(string query, WebResults.Type searchType = WebResults.Type.Song,
     int limit = 10, string pageToken = null)
 {
     return Task.FromResult(new WebResults
     {
         Albums = CreateDummyAlbums(),
         Artists = CreateDummyArtists(),
         Songs = CreateDummySongs()
     });
 }