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);
}
public Task <IDACPList> GetGenreSongsAsync(string genreName)
{
var query = DACPQueryCollection.And(DACPQueryPredicate.Is("daap.songgenre", genreName), MediaKindQuery);
DACPRequest request = GetItemsRequest(query, "name", true);
return(Server.GetAlphaGroupedListAsync(request, n => new Song(this, n)));
}
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);
}
public Task <List <Album> > GetAlbumsAsync()
{
var query = DACPQueryCollection.And(GroupQuery, Container.GroupsQuery);
DACPRequest request = Container.GetGroupsRequest(query);
return(Server.GetListAsync(request, n => new Album(Container, n)));
}
internal DACPRequest GetPlayQueueEditRequest(string command, DACPQueryElement query, PlayQueueMode mode, string sort = null)
{
DACPRequest request = new DACPRequest("/ctrl-int/1/playqueue-edit");
request.QueryParameters["command"] = command;
if (query != null)
{
request.QueryParameters["query"] = query.ToString();
}
request.QueryParameters["mode"] = ((int)mode).ToString();
if (sort != null)
{
request.QueryParameters["sort"] = sort;
}
if (this != Server.MainDatabase)
{
request.QueryParameters["srcdatabase"] = "0x" + PersistentID.ToString("x16");
}
// TODO: Handle this separately
if (mode == PlayQueueMode.Replace)
{
request.QueryParameters["clear-previous"] = "1";
}
return(request);
}
internal DACPRequest GetCueSongRequest(DACPQueryElement query, string sort, int index)
{
DACPRequest request = GetCueRequest(query, sort);
request.QueryParameters["index"] = index.ToString();
return(request);
}
public Task <List <AudiobookEpisode> > GetEpisodesAsync()
{
DACPRequest request = Container.GetItemsRequest(ItemQuery);
request.QueryParameters.Remove("sort");
return(Server.GetListAsync(request, n => new AudiobookEpisode(Container, n)));
}
public Task <IDACPList> GetUnwatchedMoviesAsync()
{
var query = DACPQueryCollection.And(DACPQueryPredicate.Is("daap.songuserplaycount", 0), MediaKindQuery);
DACPRequest request = GetItemsRequest(query, "name", true);
return(Server.GetAlphaGroupedListAsync(request, n => new Movie(this, n)));
}
internal DACPRequest GetCueShuffleRequest(DACPQueryElement query, string sort)
{
DACPRequest request = GetCueRequest(query, sort);
request.QueryParameters["dacp.shufflestate"] = "1";
return(request);
}
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);
}
public Task <IDACPList> GetGenreArtistsAsync(string genreName)
{
var query = DACPQueryCollection.And(DACPQueryPredicate.Is("daap.songgenre", genreName), DACPQueryPredicate.IsNotEmpty("daap.songartist"), MediaKindQuery);
DACPRequest request = GetGroupsRequest(query, true, "artists");
return(Server.GetAlphaGroupedListAsync(request, n => new Artist(this, n)));
}
public Task <List <PodcastEpisode> > GetUnplayedEpisodesAsync()
{
DACPRequest request = Container.GetItemsRequest(UnplayedItemQuery);
request.QueryParameters["sort"] = "releasedate";
request.QueryParameters["invert-sort-order"] = "1";
return(Server.GetListAsync(request, n => new PodcastEpisode(Container, n)));
}
private DACPRequest GetPlaySpecRequest()
{
DACPRequest request = new DACPRequest("/ctrl-int/1/playspec");
request.QueryParameters["database-spec"] = DACPQueryPredicate.Is("dmap.persistentid", "0x" + Database.PersistentID.ToString("x16")).ToString();
request.QueryParameters["container-spec"] = DACPQueryPredicate.Is("dmap.persistentid", "0x" + PersistentID.ToString("x16")).ToString();
return(request);
}
public async Task <bool> PlayQueue(PlayQueueMode mode = PlayQueueMode.Replace)
{
var query = DACPQueryPredicate.Is("dmap.itemid", ID);
DACPRequest request = Database.GetPlayQueueEditRequest("add", query, mode);
try { await Server.SubmitRequestAsync(request).ConfigureAwait(false); }
catch { return(false); }
return(true);
}
internal DACPRequest GetContainerItemsRequest()
{
DACPRequest request = new DACPRequest("/databases/{0}/containers/{1}/items", Database.ID, ID);
request.QueryParameters["meta"] = ItemsMeta;
request.QueryParameters["type"] = "music";
return(request);
}
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);
}
public async Task <bool> Play()
{
DACPRequest request = new DACPRequest("/ctrl-int/1/playspec");
request.QueryParameters["database-spec"] = DACPQueryPredicate.Is("dmap.itemid", "0x" + Database.ID.ToString("x")).ToString();
request.QueryParameters["container-spec"] = DACPQueryPredicate.Is("dmap.itemid", "0x" + ID.ToString("x")).ToString();
try { await Server.SubmitRequestAsync(request).ConfigureAwait(false); }
catch { return(false); }
return(true);
}
internal DACPRequest GetComposersRequest(bool requestSortHeaders = false)
{
DACPRequest request = new DACPRequest("/databases/{0}/browse/composers", Database.ID);
DACPQueryElement query = DACPQueryCollection.And(DACPQueryPredicate.IsNotEmpty("daap.songcomposer"), MediaKindQuery);
request.QueryParameters["filter"] = query.ToString();
if (requestSortHeaders)
{
request.QueryParameters["include-sort-headers"] = "1";
}
return(request);
}
public async Task <List <Song> > GetSongsAsync()
{
if (_songs != null)
{
return(_songs);
}
DACPRequest request = Container.GetItemsRequest(ItemQuery);
_songs = await Server.GetListAsync(request, n => new Song(Container, n)).ConfigureAwait(false);
return(_songs);
}
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); }
}
public async Task <bool> PlaySong(Song song)
{
try
{
int index = IndexOf(song);
DACPQueryElement query = DACPQueryCollection.And(DACPQueryPredicate.Is("dmap.itemname", _searchString), Database.MusicContainer.MediaKindQuery);
DACPRequest request = Database.GetCueSongRequest(query, "name", index);
await Database.Server.SubmitRequestAsync(request).ConfigureAwait(false);
}
catch { return(false); }
return(true);
}
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); }
}
private DACPRequest GetCueRequest(DACPQueryElement query, string sort)
{
DACPRequest request = new DACPRequest("/ctrl-int/1/cue");
request.QueryParameters["command"] = "play";
if (query != null)
{
request.QueryParameters["query"] = query.ToString();
}
request.QueryParameters["sort"] = sort;
request.QueryParameters["srcdatabase"] = "0x" + PersistentID.ToString("x16");
request.QueryParameters["clear-first"] = "1";
return(request);
}
public async Task <IDACPList> GetMoviesAsync()
{
if (_movies != null && _movieCacheRevision == Server.CurrentLibraryUpdateNumber)
{
return(_movies);
}
DACPRequest request = GetItemsRequest(MediaKindQuery, "name", true);
_movies = await Server.GetAlphaGroupedListAsync(request, n => new Movie(this, n));
_movieCacheRevision = Server.CurrentLibraryUpdateNumber;
return(_movies);
}
public async Task <bool> Shuffle()
{
if (Server.SupportsPlayQueue)
{
return(await Play(PlayQueueMode.Shuffle).ConfigureAwait(false));
}
DACPRequest request = GetPlaySpecRequest();
request.QueryParameters["dacp.shufflestate"] = "1";
try { await Server.SubmitRequestAsync(request).ConfigureAwait(false); }
catch { return(false); }
return(true);
}
public async Task <List <DACPItem> > GetItemsAsync()
{
if (_items != null && _itemCacheRevision == Server.CurrentLibraryUpdateNumber)
{
return(_items);
}
DACPRequest request = GetContainerItemsRequest();
_items = await Server.GetListAsync(request, n => (DACPItem) new Song(this, n)).ConfigureAwait(false);
_itemCacheRevision = Server.CurrentLibraryUpdateNumber;
return(_items);
}
internal DACPRequest GetItemsRequest(DACPQueryElement query, string sort = "album", bool requestSortHeaders = false)
{
// Apple's Remote uses the Base Playlist ID here rather than the actual container ID.
DACPRequest request = new DACPRequest("/databases/{0}/containers/{1}/items", Database.ID, Database.BasePlaylist.ID);
request.QueryParameters["meta"] = ItemsMeta;
request.QueryParameters["type"] = "music";
request.QueryParameters["sort"] = sort;
if (requestSortHeaders)
{
request.QueryParameters["include-sort-headers"] = "1";
}
if (query != null)
{
request.QueryParameters["query"] = query.ToString();
}
return(request);
}
internal DACPRequest GetGroupsRequest(DACPQueryElement query, bool includeSortHeaders = false, string groupType = "albums")
{
DACPRequest request = new DACPRequest("/databases/{0}/groups", Database.ID);
request.QueryParameters["meta"] = GroupsMeta;
request.QueryParameters["type"] = "music";
request.QueryParameters["group-type"] = groupType;
if (includeSortHeaders)
{
request.QueryParameters["include-sort-headers"] = "1";
}
request.QueryParameters["sort"] = "album";
if (query != null)
{
request.QueryParameters["query"] = query.ToString();
}
return(request);
}
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);
}
public async Task <bool> Play(PlayQueueMode mode = PlayQueueMode.Replace)
{
if (!Server.SupportsPlayQueue)
{
// Send a play request for the first item in this playlist
var items = await GetItemsAsync();
if (items == null || items.Count == 0)
{
return(false);
}
return(await PlayItem(items[0], mode).ConfigureAwait(false));
}
var query = DACPQueryPredicate.Is("dmap.itemid", ID);
DACPRequest request = Database.GetPlayQueueEditRequest("add", query, mode);
request.QueryParameters["query-modifier"] = "containers";
try { await Server.SubmitRequestAsync(request).ConfigureAwait(false); }
catch { return(false); }
return(true);
}
