Ejemplo n.º 1
0
        public async Task <List <Album> > GetAlbumsAsync()
        {
            if (_albums != null && _albumCacheRevision == Server.CurrentLibraryUpdateNumber)
            {
                return(_albums);
            }

            DACPRequest request = GetGroupsRequest(GroupsQuery, true);

            try
            {
                var response = await Server.SubmitRequestAsync(request).ConfigureAwait(false);

                _groupedAlbums = DACPUtility.GetAlphaGroupedDACPList(response.Nodes, n => new Album(this, n), out _albums);
                _albumsByID    = _albums.ToDictionary(a => a.ID);
            }
            catch
            {
                _albums        = new List <Album>();
                _albumsByID    = new Dictionary <int, Album>();
                _groupedAlbums = new DACPList <Album>(false);
            }

            _albumCacheRevision = Server.CurrentLibraryUpdateNumber;

            return(_albums);
        }
Ejemplo n.º 2
0
        public async Task <IDACPList> GetGroupedComposersAsync()
        {
            if (_groupedComposers != null)
            {
                return(_groupedComposers);
            }

            DACPRequest request = GetComposersRequest(true);

            try
            {
                var response = await Server.SubmitRequestAsync(request).ConfigureAwait(false);

                // iTunes returns an "abcp" node with "mlit" list items that only contain the composer name
                if (response.Nodes.Any(n => n.Key == "abcp"))
                {
                    _groupedComposers = DACPUtility.GetAlphaGroupedDACPList(response.Nodes, d => new DACPComposer(this, (byte[])d), "abcp");
                }
                // Apple TV returns an "mlcl" node with "mlit" items that contain an ID, persistent ID, and name
                else
                {
                    _groupedComposers = DACPUtility.GetAlphaGroupedDACPList(response.Nodes, n => new DACPComposer(this, (DACPNodeDictionary)n));
                }
            }
            catch
            {
                _groupedComposers = new DACPList <DACPComposer>(false);
            }

            return(_groupedComposers);
        }
Ejemplo n.º 3
0
        public async Task <List <Artist> > GetArtistsAsync()
        {
            if (_artists != null && _artistCacheRevision == Server.CurrentLibraryUpdateNumber)
            {
                return(_artists);
            }

            var         query   = DACPQueryCollection.And(DACPQueryPredicate.IsNotEmpty("daap.songartist"), MediaKindQuery);
            DACPRequest request = GetGroupsRequest(query, true, "artists");

            try
            {
                var response = await Server.SubmitRequestAsync(request).ConfigureAwait(false);

                _groupedArtists = DACPUtility.GetAlphaGroupedDACPList(response.Nodes, n => new Artist(this, n), out _artists);
                _artistsByID    = _artists.ToDictionary(a => a.ID);
            }
            catch
            {
                _artists        = new List <Artist>();
                _artistsByID    = new Dictionary <int, Artist>();
                _groupedArtists = new DACPList <Artist>(false);
            }

            _artistCacheRevision = Server.CurrentLibraryUpdateNumber;

            return(_artists);
        }
Ejemplo n.º 4
0
        public async Task <bool> RequestStationsAsync()
        {
            DACPRequest request = new DACPRequest("/databases/{0}/containers", ID);

            request.QueryParameters["meta"] = "dmap.itemname,dmap.itemid,com.apple.itunes.cloud-id,dmap.downloadstatus,dmap.persistentid,daap.baseplaylist,com.apple.itunes.special-playlist,com.apple.itunes.smart-playlist,com.apple.itunes.saved-genius,dmap.parentcontainerid,dmap.editcommandssupported,com.apple.itunes.jukebox-current,daap.songcontentdescription,dmap.haschildcontainers";

            try
            {
                var response = await Server.SubmitRequestAsync(request).ConfigureAwait(false);

                var containers = DACPUtility.GetItemsFromNodes(response.Nodes, n => DACPContainer.GetContainer(this, n));

                List <iTunesRadioStation> newStations         = new List <iTunesRadioStation>();
                List <iTunesRadioStation> newFeaturedStations = new List <iTunesRadioStation>();

                // There is a property (aeRf) that indicates whether a station is a "featured" station, but in some cases
                // featured stations may not have this property set to "true".
                // For now, checking the index of the last "featured" station as a workaround.

                int lastFeaturedStationIndex = 0;
                var stations = containers.Where(c => c.Type == ContainerType.iTunesRadio).Select(c => (iTunesRadioStation)c).ToArray();

                for (int i = 0; i < stations.Length; i++)
                {
                    if (stations[i].IsFeaturedStation)
                    {
                        lastFeaturedStationIndex = i;
                    }
                }

                for (int i = 0; i < stations.Length; i++)
                {
                    if (i <= lastFeaturedStationIndex)
                    {
                        newFeaturedStations.Add(stations[i]);
                    }
                    else
                    {
                        newStations.Add(stations[i]);
                    }
                }

                Stations         = newStations;
                FeaturedStations = newFeaturedStations;
            }
            catch (Exception e)
            {
                Stations         = new List <iTunesRadioStation>();
                FeaturedStations = new List <iTunesRadioStation>();

                Server.HandleHTTPException(request, e);
                return(false);
            }

            return(true);
        }
Ejemplo n.º 5
0
        public async Task <List <Audiobook> > SearchAudiobooksAsync(string searchString, CancellationToken cancellationToken)
        {
            DACPQueryElement query   = DACPQueryCollection.And(DACPQueryPredicate.Is("daap.songalbum", searchString), MediaKindQuery);
            DACPRequest      request = GetGroupsRequest(query, false, "albums");

            request.CancellationToken = cancellationToken;
            try
            {
                var response = await Server.SubmitRequestAsync(request).ConfigureAwait(false);

                return(DACPUtility.GetItemsFromNodes(response.Nodes, n => new Audiobook(this, n)).ToList());
            }
            catch { return(null); }
        }
Ejemplo n.º 6
0
        public async Task <List <Song> > SearchSongsAsync(string searchString, CancellationToken cancellationToken)
        {
            DACPQueryElement query   = DACPQueryCollection.And(DACPQueryPredicate.Is("dmap.itemname", searchString), MediaKindQuery);
            DACPRequest      request = GetItemsRequest(query, "name", false);

            request.CancellationToken = cancellationToken;
            try
            {
                var response = await Server.SubmitRequestAsync(request).ConfigureAwait(false);

                return(DACPUtility.GetItemsFromNodes(response.Nodes, n => new Song(this, n)).ToList());
            }
            catch { return(null); }
        }
Ejemplo n.º 7
0
        public async Task <IDACPList> GetGroupedItemsAsync()
        {
            if (_groupedItems != null)
            {
                return(_groupedItems);
            }

            var         query   = DACPQueryCollection.And(DACPQueryPredicate.Is("daap.songcomposer", Name), Container.MediaKindQuery);
            DACPRequest request = Container.GetItemsRequest(query, "album", false);

            try
            {
                var response = await Server.SubmitRequestAsync(request).ConfigureAwait(false);

                var items = DACPUtility.GetItemsFromNodes(response.Nodes, n => new DACPItem(Container, n)).ToList();

                ItemGroup <DACPItem>             currentGroup = null;
                DACPList <ItemGroup <DACPItem> > result       = new DACPList <ItemGroup <DACPItem> >(true);

                foreach (var item in items)
                {
                    if (currentGroup == null || currentGroup.Key != item.AlbumName)
                    {
                        currentGroup = new ItemGroup <DACPItem>(item.AlbumName);
                        result.Add(currentGroup);
                    }
                    currentGroup.Add(item);
                }

                _items        = items;
                _groupedItems = result;
            }
            catch
            {
                _items        = new List <DACPItem>();
                _groupedItems = new DACPList <DACPItem>(false);
            }

            return(_groupedItems);
        }
Ejemplo n.º 8
0
        public async Task <IDACPList> GetGroupedItemsAsync()
        {
            if (_groupedItems != null)
            {
                return(_groupedItems);
            }

            var         query   = DACPQueryCollection.And(DACPQueryPredicate.Is("daap.songgenre", Name), Container.MediaKindQuery);
            DACPRequest request = Container.GetItemsRequest(query, "name", true);

            try
            {
                var response = await Server.SubmitRequestAsync(request).ConfigureAwait(false);

                _groupedItems = DACPUtility.GetAlphaGroupedDACPList(response.Nodes, n => new DACPItem(Container, n), out _items);
            }
            catch
            {
                _items        = new List <DACPItem>();
                _groupedItems = new DACPList <DACPItem>(false);
            }

            return(_groupedItems);
        }
Ejemplo n.º 9
0
        public async Task <bool> RequestContainersAsync()
        {
            DACPRequest request = new DACPRequest("/databases/{0}/containers", ID);

            request.QueryParameters["meta"] = "dmap.itemname,dmap.itemid,com.apple.itunes.cloud-id,dmap.downloadstatus,dmap.persistentid,daap.baseplaylist,com.apple.itunes.special-playlist,com.apple.itunes.smart-playlist,com.apple.itunes.saved-genius,dmap.parentcontainerid,dmap.editcommandssupported,com.apple.itunes.jukebox-current,daap.songcontentdescription,dmap.haschildcontainers";

            try
            {
                var response = await Server.SubmitRequestAsync(request).ConfigureAwait(false);

                var containers = DACPUtility.GetItemsFromNodes(response.Nodes, n => DACPContainer.GetContainer(this, n));

                List <Playlist>  newPlaylists       = new List <Playlist>();
                List <Playlist>  newParentPlaylists = new List <Playlist>();
                List <GeniusMix> newGeniusMixes     = new List <GeniusMix>();

                foreach (DACPContainer container in containers)
                {
                    if (container.BasePlaylist)
                    {
                        BasePlaylist = container;
                        if (Server.IsAppleTV && container is MusicContainer)
                        {
                            MusicContainer = (MusicContainer)container;
                        }
                        continue;
                    }

                    switch (container.Type)
                    {
                    case ContainerType.Playlist:
                        newPlaylists.Add((Playlist)container);
                        if (container.ParentContainerID == 0)
                        {
                            newParentPlaylists.Add((Playlist)container);
                        }
                        break;

                    case ContainerType.Music:
                        MusicContainer = (MusicContainer)container;
                        break;

                    case ContainerType.Movies:
                        MoviesContainer = (MoviesContainer)container;
                        break;

                    case ContainerType.TVShows:
                        TVShowsContainer = (TVShowsContainer)container;
                        break;

                    case ContainerType.Podcasts:
                        PodcastsContainer = (PodcastsContainer)container;
                        break;

                    case ContainerType.iTunesU:
                        iTunesUContainer = (iTunesUContainer)container;
                        break;

                    case ContainerType.Books:
                        BooksContainer = (BooksContainer)container;
                        break;

                    case ContainerType.Purchased:
                        break;

                    case ContainerType.Rentals:
                        break;

                    case ContainerType.GeniusMixes:
                        break;

                    case ContainerType.GeniusMix:
                        newGeniusMixes.Add((GeniusMix)container);
                        break;

                    default:
                        break;
                    }
                }

                Playlists       = newPlaylists;
                ParentPlaylists = newParentPlaylists;
                GeniusMixes     = newGeniusMixes;
            }
            catch (Exception e)
            {
                Server.HandleHTTPException(request, e);
                return(false);
            }

            return(true);
        }
Ejemplo n.º 10
0
 public override string ToString()
 {
     return("'" + _key + _operator + Uri.EscapeDataString(DACPUtility.EscapeSingleQuotes(_value)) + "'");
 }
Ejemplo n.º 11
0
 public DACPGenre(DACPContainer container, byte[] data)
     : this(container, DACPUtility.GetStringValue(data))
 {
 }
Ejemplo n.º 12
0
        public async Task <bool> PlayItem(DACPItem item, PlayQueueMode mode = PlayQueueMode.Replace)
        {
            DACPRequest request;

            if (Server.SupportsPlayQueue)
            {
                request = Database.GetPlayQueueEditRequest("add", DACPQueryPredicate.Is("dmap.itemid", item.ID), mode, "name");
                request.QueryParameters["queuefilter"] = string.Format("genre:{0}", Uri.EscapeDataString(DACPUtility.EscapeSingleQuotes(Name)));
            }
            else
            {
                var items = await GetItemsAsync();

                int index = items.FindIndex(i => i.ID == item.ID);
                if (index < 0)
                {
                    return(false);
                }
                request = Database.GetCueSongRequest(DACPQueryCollection.And(GenreQuery, Container.MediaKindQuery), "name", index);
            }

            try { await Server.SubmitRequestAsync(request).ConfigureAwait(false); }
            catch { return(false); }
            return(true);
        }