Esempio n. 1
0
        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);
            }
        }
Esempio n. 2
0
        private async Task MakeCallAsync(string qry, Namespace nspc = Namespace.music, int maxItems = 5)
        {
            if (_client == null)
            {
                return;
            }
            string          country        = null;
            ContentResponse searchResponse = await _client.SearchAsync(nspc, qry, source : ContentSource.Catalog, filter : SearchFilter.Albums, maxItems : maxItems, country : country);

            if (searchResponse.Albums != null)
            {
                var count = searchResponse.Albums.TotalItemCount;
                Albums = searchResponse.Albums.Items;
            }
            else
            {
                Albums = null;
            }
        }
Esempio n. 3
0
        private async void BtnSearch_Click(object sender, RoutedEventArgs e)
        {
            // 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;

            ResultList.Items.Clear();

            if (!string.IsNullOrEmpty(SearchText.Text))
            {
                // Search for albums in your current geography
                ContentResponse searchResponse = await client.SearchAsync(Namespace.music, SearchText.Text, filter : SearchFilter.Albums);

                foreach (Album albumResult in searchResponse.Albums.Items)
                {
                    ResultList.Items.Add(albumResult);
                }
            }
        }
        public async Task TestGettingStarted()
        {
            // Start by registering an Azure Data Market client ID and secret ( see http://music.xbox.com/developer )

            // Create a client
            //IXboxMusicClient client = XboxMusicClientFactory.CreateXboxMusicClient("MyClientId", "YourClientSecretYourClientSecretYourSecret=");
            string           clientid     = ConfigurationManager.AppSettings["clientid"];
            string           clientsecret = ConfigurationManager.AppSettings["clientsecret"];
            IXboxMusicClient client       = XboxMusicClientFactory.CreateXboxMusicClient(clientid, clientsecret);

            // 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(Namespace.music, "Foo Fighters", filter : SearchFilter.Albums, maxItems : 5, country : country);

            Console.WriteLine("Found {0} albums", searchResponse.Albums.TotalItemCount);
            foreach (Album albumResult in searchResponse.Albums.Items)
            {
                Console.WriteLine("{0}", 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: {0} (link: {1}, image: {2})", album.Name, album.GetLink(ContentExtensions.LinkAction.Play), album.GetImageUrl(800, 800));
            foreach (Contributor contributor in album.Artists)
            {
                Artist artist = contributor.Artist;
                Console.WriteLine("Artist: {0} (link: {1}, image: {2})", artist.Name, artist.GetLink(), artist.GetImageUrl(1920, 1080));
            }
            foreach (Track track in album.Tracks.Items)
            {
                Console.WriteLine("Track: {0} - {1}", track.TrackNumber, track.Name);
            }
        }