private ServerItem ParseItemId(string id, User user)
{
Guid itemId;
StubType?stubType = null;
if (id.StartsWith("folder_", StringComparison.OrdinalIgnoreCase))
{
stubType = StubType.Folder;
id = id.Split(new[] { '_' }, 2)[1];
}
else if (id.StartsWith("people_", StringComparison.OrdinalIgnoreCase))
{
stubType = StubType.People;
id = id.Split(new[] { '_' }, 2)[1];
}
if (Guid.TryParse(id, out itemId))
{
var item = _libraryManager.GetItemById(itemId);
return(new ServerItem
{
Item = item,
StubType = stubType
});
}
Logger.Error("Error parsing item Id: {0}. Returning user root folder.", id);
return(new ServerItem {
Item = user.RootFolder
});
}
private QueryResult <ServerItem> GetUserItems(BaseItem item, StubType?stubType, User user, SortCriteria sort, int?startIndex, int?limit)
{
if (item is MusicGenre)
{
return(GetMusicGenreItems(item, null, user, sort, startIndex, limit));
}
if (item is MusicArtist)
{
return(GetMusicArtistItems(item, null, user, sort, startIndex, limit));
}
if (stubType.HasValue)
{
if (stubType.Value == StubType.People)
{
var items = _libraryManager.GetPeopleItems(new InternalPeopleQuery
{
ItemId = item.Id
}).ToArray();
var result = new QueryResult <ServerItem>
{
Items = items.Select(i => new ServerItem(i)).ToArray(),
TotalRecordCount = items.Length
};
return(ApplyPaging(result, startIndex, limit));
}
var person = item as Person;
if (person != null)
{
return(GetItemsFromPerson(person, user, startIndex, limit));
}
return(ApplyPaging(new QueryResult <ServerItem>(), startIndex, limit));
}
var folder = (Folder)item;
var query = new InternalItemsQuery
{
Limit = limit,
StartIndex = startIndex,
User = user,
IsMissing = false,
PresetViews = new[] { CollectionType.Movies, CollectionType.TvShows, CollectionType.Music },
ExcludeItemTypes = new[] { typeof(Game).Name, typeof(Book).Name },
IsPlaceHolder = false,
DtoOptions = GetDtoOptions()
};
SetSorting(query, sort, folder.IsPreSorted);
var queryResult = folder.GetItems(query);
return(ToResult(queryResult));
}
public ServerItem(BaseItem item)
{
Item = item;
if (item is IItemByName && !(item is Folder))
{
StubType = Dlna.ContentDirectory.StubType.Folder;
}
}
private void AddCover(BaseItem item, StubType?stubType, XmlWriter writer)
{
ImageDownloadInfo imageInfo = GetImageInfo(item);
if (imageInfo == null)
{
return;
}
// TODO: Remove these default values
var albumArtUrlInfo = GetImageUrl(
imageInfo,
_profile.MaxAlbumArtWidth ?? 10000,
_profile.MaxAlbumArtHeight ?? 10000,
"jpg");
writer.WriteStartElement("upnp", "albumArtURI", NsUpnp);
if (!string.IsNullOrEmpty(_profile.AlbumArtPn))
{
writer.WriteAttributeString("dlna", "profileID", NsDlna, _profile.AlbumArtPn);
}
writer.WriteString(albumArtUrlInfo.url);
writer.WriteFullEndElement();
// TODO: Remove these default values
var iconUrlInfo = GetImageUrl(
imageInfo,
_profile.MaxIconWidth ?? 48,
_profile.MaxIconHeight ?? 48,
"jpg");
writer.WriteElementString("upnp", "icon", NsUpnp, iconUrlInfo.url);
if (!_profile.EnableAlbumArtInDidl)
{
if (string.Equals(item.MediaType, MediaType.Audio, StringComparison.OrdinalIgnoreCase) ||
string.Equals(item.MediaType, MediaType.Video, StringComparison.OrdinalIgnoreCase))
{
if (!stubType.HasValue)
{
return;
}
}
}
if (!_profile.EnableSingleAlbumArtLimit || string.Equals(item.MediaType, MediaType.Photo, StringComparison.OrdinalIgnoreCase))
{
AddImageResElement(item, writer, 4096, 4096, "jpg", "JPEG_LRG");
AddImageResElement(item, writer, 1024, 768, "jpg", "JPEG_MED");
AddImageResElement(item, writer, 640, 480, "jpg", "JPEG_SM");
AddImageResElement(item, writer, 4096, 4096, "png", "PNG_LRG");
AddImageResElement(item, writer, 160, 160, "png", "PNG_TN");
}
AddImageResElement(item, writer, 160, 160, "jpg", "JPEG_TN");
}
public void WriteItemElement(
DlnaOptions options,
XmlWriter writer,
BaseItem item,
User user,
BaseItem context,
StubType?contextStubType,
string deviceId,
Filter filter,
StreamInfo streamInfo = null)
{
var clientId = GetClientId(item, null);
writer.WriteStartElement(string.Empty, "item", NS_DIDL);
writer.WriteAttributeString("restricted", "1");
writer.WriteAttributeString("id", clientId);
if (context != null)
{
writer.WriteAttributeString("parentID", GetClientId(context, contextStubType));
}
else
{
var parent = item.DisplayParentId;
if (!parent.Equals(Guid.Empty))
{
writer.WriteAttributeString("parentID", GetClientId(parent, null));
}
}
AddGeneralProperties(item, null, context, writer, filter);
AddSamsungBookmarkInfo(item, user, writer);
// refID?
// storeAttribute(itemNode, object, ClassProperties.REF_ID, false);
var hasMediaSources = item as IHasMediaSources;
if (hasMediaSources != null)
{
if (string.Equals(item.MediaType, MediaType.Audio, StringComparison.OrdinalIgnoreCase))
{
AddAudioResource(options, writer, item, deviceId, filter, streamInfo);
}
else if (string.Equals(item.MediaType, MediaType.Video, StringComparison.OrdinalIgnoreCase))
{
AddVideoResource(options, writer, item, deviceId, filter, streamInfo);
}
}
AddCover(item, context, null, writer);
writer.WriteFullEndElement();
}
public static string GetClientId(Guid idValue, StubType?stubType)
{
var id = idValue.ToString("N", CultureInfo.InvariantCulture);
if (stubType.HasValue)
{
id = stubType.Value.ToString().ToLowerInvariant() + "_" + id;
}
return(id);
}
public static string GetClientId(BaseItem item, StubType?stubType)
{
var id = item.Id.ToString("N");
if (stubType.HasValue)
{
id = stubType.Value.ToString().ToLower() + "_" + id;
}
return(id);
}
public static string GetClientId(Guid idValue, StubType?stubType)
{
var id = idValue.ToString("N");
if (stubType.HasValue)
{
id = stubType.Value.ToString().ToLower() + "_" + id;
}
return(id);
}
/// <summary>
/// Initializes a new instance of the <see cref="ServerItem"/> class.
/// </summary>
/// <param name="item">The <see cref="BaseItem"/>.</param>
/// <param name="stubType">The stub type.</param>
public ServerItem(BaseItem item, StubType?stubType)
{
Item = item;
if (stubType.HasValue)
{
StubType = stubType;
}
else if (item is IItemByName and not Folder)
{
StubType = Dlna.ContentDirectory.StubType.Folder;
}
}
private string GetDisplayName(BaseItem item, StubType?itemStubType, BaseItem context)
{
if (itemStubType.HasValue)
{
switch (itemStubType.Value)
{
case StubType.Latest: return(_localization.GetLocalizedString("Latest"));
case StubType.Playlists: return(_localization.GetLocalizedString("Playlists"));
case StubType.AlbumArtists: return(_localization.GetLocalizedString("HeaderAlbumArtists"));
case StubType.Albums: return(_localization.GetLocalizedString("Albums"));
case StubType.Artists: return(_localization.GetLocalizedString("Artists"));
case StubType.Songs: return(_localization.GetLocalizedString("Songs"));
case StubType.Genres: return(_localization.GetLocalizedString("Genres"));
case StubType.FavoriteAlbums: return(_localization.GetLocalizedString("HeaderFavoriteAlbums"));
case StubType.FavoriteArtists: return(_localization.GetLocalizedString("HeaderFavoriteArtists"));
case StubType.FavoriteSongs: return(_localization.GetLocalizedString("HeaderFavoriteSongs"));
case StubType.ContinueWatching: return(_localization.GetLocalizedString("HeaderContinueWatching"));
case StubType.Movies: return(_localization.GetLocalizedString("Movies"));
case StubType.Collections: return(_localization.GetLocalizedString("Collections"));
case StubType.Favorites: return(_localization.GetLocalizedString("Favorites"));
case StubType.NextUp: return(_localization.GetLocalizedString("HeaderNextUp"));
case StubType.FavoriteSeries: return(_localization.GetLocalizedString("HeaderFavoriteShows"));
case StubType.FavoriteEpisodes: return(_localization.GetLocalizedString("HeaderFavoriteEpisodes"));
case StubType.Series: return(_localization.GetLocalizedString("Shows"));
default: break;
}
}
return(item is Episode episode
? GetEpisodeDisplayName(episode, context)
: item.Name);
}
private void AddCover(BaseItem item, BaseItem context, StubType?stubType, XmlWriter writer)
{
ImageDownloadInfo imageInfo = null;
// Finally, just use the image from the item
if (imageInfo == null)
{
imageInfo = GetImageInfo(item);
}
if (imageInfo == null)
{
return;
}
var albumartUrlInfo = GetImageUrl(imageInfo, _profile.MaxAlbumArtWidth, _profile.MaxAlbumArtHeight, "jpg");
writer.WriteStartElement("upnp", "albumArtURI", NS_UPNP);
writer.WriteAttributeString("dlna", "profileID", NS_DLNA, _profile.AlbumArtPn);
writer.WriteString(albumartUrlInfo.Url);
writer.WriteFullEndElement();
// TOOD: Remove these default values
var iconUrlInfo = GetImageUrl(imageInfo, _profile.MaxIconWidth ?? 48, _profile.MaxIconHeight ?? 48, "jpg");
writer.WriteElementString("upnp", "icon", NS_UPNP, iconUrlInfo.Url);
if (!_profile.EnableAlbumArtInDidl)
{
if (string.Equals(item.MediaType, MediaType.Audio, StringComparison.OrdinalIgnoreCase) ||
string.Equals(item.MediaType, MediaType.Video, StringComparison.OrdinalIgnoreCase))
{
if (!stubType.HasValue)
{
return;
}
}
}
AddImageResElement(item, writer, 160, 160, "jpg", "JPEG_TN");
if (!_profile.EnableSingleAlbumArtLimit)
{
AddImageResElement(item, writer, 4096, 4096, "jpg", "JPEG_LRG");
AddImageResElement(item, writer, 1024, 768, "jpg", "JPEG_MED");
AddImageResElement(item, writer, 640, 480, "jpg", "JPEG_SM");
AddImageResElement(item, writer, 4096, 4096, "png", "PNG_LRG");
AddImageResElement(item, writer, 160, 160, "png", "PNG_TN");
}
}
private QueryResult <ServerItem> GetFolders(BaseItem item, User user, StubType?stubType, SortCriteria sort, int?startIndex, int?limit)
{
var folders = _libraryManager.GetUserRootFolder().GetChildren(user, true)
.OrderBy(i => i.SortName)
.Select(i => new ServerItem(i)
{
StubType = StubType.Folder
})
.ToArray();
return(new QueryResult <ServerItem>
{
Items = folders,
TotalRecordCount = folders.Length
});
}
private QueryResult <ServerItem> GetLiveTvChannels(BaseItem item, User user, StubType?stubType, SortCriteria sort, int?startIndex, int?limit)
{
var query = new InternalItemsQuery(user)
{
StartIndex = startIndex,
Limit = limit,
};
query.IncludeItemTypes = new[] { typeof(LiveTvChannel).Name };
SetSorting(query, sort, false);
var result = _libraryManager.GetItemsResult(query);
return(ToResult(result));
}
private void AddGeneralProperties(BaseItem item, StubType?itemStubType, BaseItem context, XmlWriter writer, Filter filter)
{
AddCommonFields(item, itemStubType, context, writer, filter);
var hasArtists = item as IHasArtist;
var hasAlbumArtists = item as IHasAlbumArtist;
if (hasArtists != null)
{
foreach (var artist in hasArtists.Artists)
{
AddValue(writer, "upnp", "artist", artist, NS_UPNP);
AddValue(writer, "dc", "creator", artist, NS_DC);
// If it doesn't support album artists (musicvideo), then tag as both
if (hasAlbumArtists == null)
{
AddAlbumArtist(writer, artist);
}
}
}
if (hasAlbumArtists != null)
{
foreach (var albumArtist in hasAlbumArtists.AlbumArtists)
{
AddAlbumArtist(writer, albumArtist);
}
}
if (!string.IsNullOrWhiteSpace(item.Album))
{
AddValue(writer, "upnp", "album", item.Album, NS_UPNP);
}
if (item.IndexNumber.HasValue)
{
AddValue(writer, "upnp", "originalTrackNumber", item.IndexNumber.Value.ToString(_usCulture), NS_UPNP);
if (item is Episode)
{
AddValue(writer, "upnp", "episodeNumber", item.IndexNumber.Value.ToString(_usCulture), NS_UPNP);
}
}
}
private ServerItem ParseItemId(string id, User user)
{
Guid itemId;
StubType?stubType = null;
// After using PlayTo, MediaMonkey sends a request to the server trying to get item info
const string paramsSrch = "Params=";
var paramsIndex = id.IndexOf(paramsSrch, StringComparison.OrdinalIgnoreCase);
if (paramsIndex != -1)
{
id = id.Substring(paramsIndex + paramsSrch.Length);
var parts = id.Split(';');
id = parts[24];
}
if (id.StartsWith("folder_", StringComparison.OrdinalIgnoreCase))
{
stubType = StubType.Folder;
id = id.Split(new[] { '_' }, 2)[1];
}
else if (id.StartsWith("people_", StringComparison.OrdinalIgnoreCase))
{
stubType = StubType.People;
id = id.Split(new[] { '_' }, 2)[1];
}
if (Guid.TryParse(id, out itemId))
{
var item = _libraryManager.GetItemById(itemId);
return(new ServerItem
{
Item = item,
StubType = stubType
});
}
Logger.Error("Error parsing item Id: {0}. Returning user root folder.", id);
return(new ServerItem {
Item = user.RootFolder
});
}
private ServerItem ParseItemId(string id, User user)
{
Guid itemId;
StubType?stubType = null;
// After using PlayTo, MediaMonkey sends a request to the server trying to get item info
const string paramsSrch = "Params=";
var paramsIndex = id.IndexOf(paramsSrch, StringComparison.OrdinalIgnoreCase);
if (paramsIndex != -1)
{
id = id.Substring(paramsIndex + paramsSrch.Length);
var parts = id.Split(';');
id = parts[23];
}
var enumNames = Enum.GetNames(typeof(StubType));
foreach (var name in enumNames)
{
if (id.StartsWith(name + "_", StringComparison.OrdinalIgnoreCase))
{
stubType = (StubType)Enum.Parse(typeof(StubType), name, true);
id = id.Split(new[] { '_' }, 2)[1];
break;
}
}
if (Guid.TryParse(id, out itemId))
{
var item = _libraryManager.GetItemById(itemId);
return(new ServerItem(item)
{
StubType = stubType
});
}
Logger.Error("Error parsing item Id: {0}. Returning user root folder.", id);
return(new ServerItem(user.RootFolder));
}
public void WriteFolderElement(XmlWriter writer, BaseItem folder, StubType?stubType, BaseItem context, int childCount, Filter filter, string requestedId = null)
{
writer.WriteStartElement(string.Empty, "container", NS_DIDL);
writer.WriteAttributeString("restricted", "0");
writer.WriteAttributeString("searchable", "1");
writer.WriteAttributeString("childCount", childCount.ToString(_usCulture));
var clientId = GetClientId(folder, stubType);
if (string.Equals(requestedId, "0"))
{
writer.WriteAttributeString("id", "0");
writer.WriteAttributeString("parentID", "-1");
}
else
{
writer.WriteAttributeString("id", clientId);
if (context != null)
{
writer.WriteAttributeString("parentID", GetClientId(context, null));
}
else
{
var parent = folder.DisplayParentId;
if (!parent.HasValue)
{
writer.WriteAttributeString("parentID", "0");
}
else
{
writer.WriteAttributeString("parentID", GetClientId(parent.Value, null));
}
}
}
AddGeneralProperties(folder, stubType, context, writer, filter);
AddCover(folder, context, stubType, writer);
writer.WriteFullEndElement();
}
public XmlElement GetFolderElement(XmlDocument doc, BaseItem folder, StubType?stubType, BaseItem context, int childCount, Filter filter, string requestedId = null)
{
var container = doc.CreateElement(string.Empty, "container", NS_DIDL);
container.SetAttribute("restricted", "0");
container.SetAttribute("searchable", "1");
container.SetAttribute("childCount", childCount.ToString(_usCulture));
var clientId = GetClientId(folder, stubType);
if (string.Equals(requestedId, "0"))
{
container.SetAttribute("id", "0");
container.SetAttribute("parentID", "-1");
}
else
{
container.SetAttribute("id", clientId);
if (context != null)
{
container.SetAttribute("parentID", GetClientId(context, null));
}
else
{
var parent = folder.DisplayParentId;
if (!parent.HasValue)
{
container.SetAttribute("parentID", "0");
}
else
{
container.SetAttribute("parentID", GetClientId(parent.Value, null));
}
}
}
AddCommonFields(folder, stubType, null, container, filter);
AddCover(folder, context, stubType, container);
return(container);
}
private string GetDisplayName(BaseItem item, StubType?itemStubType, BaseItem context)
{
if (itemStubType.HasValue && itemStubType.Value == StubType.People)
{
if (item is Video)
{
return(_localization.GetLocalizedString("HeaderCastCrew"));
}
return(_localization.GetLocalizedString("HeaderPeople"));
}
var episode = item as Episode;
var season = context as Season;
if (episode != null && season != null)
{
// This is a special embedded within a season
if (item.ParentIndexNumber.HasValue && item.ParentIndexNumber.Value == 0)
{
if (season.IndexNumber.HasValue && season.IndexNumber.Value != 0)
{
return(string.Format(_localization.GetLocalizedString("ValueSpecialEpisodeName"), item.Name));
}
}
if (item.IndexNumber.HasValue)
{
var number = item.IndexNumber.Value.ToString("00").ToString(CultureInfo.InvariantCulture);
if (episode.IndexNumberEnd.HasValue)
{
number += "-" + episode.IndexNumberEnd.Value.ToString("00").ToString(CultureInfo.InvariantCulture);
}
return(number + " - " + item.Name);
}
}
return(item.Name);
}
private void AddCover(BaseItem item, BaseItem context, StubType?stubType, XmlWriter writer)
{
ImageDownloadInfo imageInfo = null;
if (context is UserView)
{
var episode = item as Episode;
if (episode != null)
{
var parent = episode.Series;
if (parent != null)
{
imageInfo = GetImageInfo(parent);
}
}
}
// Finally, just use the image from the item
if (imageInfo == null)
{
imageInfo = GetImageInfo(item);
}
if (imageInfo == null)
{
return;
}
var playbackPercentage = 0;
var unplayedCount = 0;
if (item is Video)
{
var userData = _userDataManager.GetUserDataDto(item, _user);
playbackPercentage = Convert.ToInt32(userData.PlayedPercentage ?? 0);
if (playbackPercentage >= 100 || userData.Played)
{
playbackPercentage = 100;
}
}
else if (item is Series || item is Season || item is BoxSet)
{
var userData = _userDataManager.GetUserDataDto(item, _user);
if (userData.Played)
{
playbackPercentage = 100;
}
else
{
unplayedCount = userData.UnplayedItemCount ?? 0;
}
}
var albumartUrlInfo = GetImageUrl(imageInfo, _profile.MaxAlbumArtWidth, _profile.MaxAlbumArtHeight, playbackPercentage, unplayedCount, "jpg");
writer.WriteStartElement("upnp", "albumArtURI", NS_UPNP);
writer.WriteAttributeString("dlna", "profileID", NS_DLNA, _profile.AlbumArtPn);
writer.WriteString(albumartUrlInfo.Url);
writer.WriteFullEndElement();
// TOOD: Remove these default values
var iconUrlInfo = GetImageUrl(imageInfo, _profile.MaxIconWidth ?? 48, _profile.MaxIconHeight ?? 48, playbackPercentage, unplayedCount, "jpg");
writer.WriteElementString("upnp", "icon", NS_UPNP, iconUrlInfo.Url);
if (!_profile.EnableAlbumArtInDidl)
{
if (string.Equals(item.MediaType, MediaType.Audio, StringComparison.OrdinalIgnoreCase) ||
string.Equals(item.MediaType, MediaType.Video, StringComparison.OrdinalIgnoreCase))
{
if (!stubType.HasValue)
{
return;
}
}
}
AddImageResElement(item, writer, 160, 160, playbackPercentage, unplayedCount, "jpg", "JPEG_TN");
if (!_profile.EnableSingleAlbumArtLimit)
{
AddImageResElement(item, writer, 4096, 4096, playbackPercentage, unplayedCount, "jpg", "JPEG_LRG");
AddImageResElement(item, writer, 1024, 768, playbackPercentage, unplayedCount, "jpg", "JPEG_MED");
AddImageResElement(item, writer, 640, 480, playbackPercentage, unplayedCount, "jpg", "JPEG_SM");
AddImageResElement(item, writer, 4096, 4096, playbackPercentage, unplayedCount, "png", "PNG_LRG");
AddImageResElement(item, writer, 160, 160, playbackPercentage, unplayedCount, "png", "PNG_TN");
}
}
private void AddGeneralProperties(BaseItem item, StubType?itemStubType, BaseItem context, XmlWriter writer, Filter filter)
{
AddCommonFields(item, itemStubType, context, writer, filter);
var audio = item as Audio;
if (audio != null)
{
foreach (var artist in audio.Artists)
{
AddValue(writer, "upnp", "artist", artist, NS_UPNP);
}
if (!string.IsNullOrEmpty(audio.Album))
{
AddValue(writer, "upnp", "album", audio.Album, NS_UPNP);
}
foreach (var artist in audio.AlbumArtists)
{
AddAlbumArtist(writer, artist);
}
}
var album = item as MusicAlbum;
if (album != null)
{
foreach (var artist in album.AlbumArtists)
{
AddAlbumArtist(writer, artist);
AddValue(writer, "upnp", "artist", artist, NS_UPNP);
}
foreach (var artist in album.Artists)
{
AddValue(writer, "upnp", "artist", artist, NS_UPNP);
}
}
var musicVideo = item as MusicVideo;
if (musicVideo != null)
{
foreach (var artist in musicVideo.Artists)
{
AddValue(writer, "upnp", "artist", artist, NS_UPNP);
AddAlbumArtist(writer, artist);
}
if (!string.IsNullOrEmpty(musicVideo.Album))
{
AddValue(writer, "upnp", "album", musicVideo.Album, NS_UPNP);
}
}
if (item.IndexNumber.HasValue)
{
AddValue(writer, "upnp", "originalTrackNumber", item.IndexNumber.Value.ToString(_usCulture), NS_UPNP);
if (item is Episode)
{
AddValue(writer, "upnp", "episodeNumber", item.IndexNumber.Value.ToString(_usCulture), NS_UPNP);
}
}
}
private void WriteObjectClass(XmlWriter writer, BaseItem item, StubType?stubType)
{
// More types here
// http://oss.linn.co.uk/repos/Public/LibUpnpCil/DidlLite/UpnpAv/Test/TestDidlLite.cs
writer.WriteStartElement("upnp", "class", NS_UPNP);
if (item.IsDisplayedAsFolder || stubType.HasValue)
{
string classType = null;
if (!_profile.RequiresPlainFolders)
{
if (item is MusicAlbum)
{
classType = "object.container.album.musicAlbum";
}
else if (item is MusicArtist)
{
classType = "object.container.person.musicArtist";
}
else if (item is Series || item is Season || item is BoxSet || item is Video)
{
classType = "object.container.album.videoAlbum";
}
else if (item is Playlist)
{
classType = "object.container.playlistContainer";
}
else if (item is PhotoAlbum)
{
classType = "object.container.album.photoAlbum";
}
}
writer.WriteString(classType ?? "object.container.storageFolder");
}
else if (string.Equals(item.MediaType, MediaType.Audio, StringComparison.OrdinalIgnoreCase))
{
writer.WriteString("object.item.audioItem.musicTrack");
}
else if (string.Equals(item.MediaType, MediaType.Photo, StringComparison.OrdinalIgnoreCase))
{
writer.WriteString("object.item.imageItem.photo");
}
else if (string.Equals(item.MediaType, MediaType.Video, StringComparison.OrdinalIgnoreCase))
{
if (!_profile.RequiresPlainVideoItems && item is Movie)
{
writer.WriteString("object.item.videoItem.movie");
}
else if (!_profile.RequiresPlainVideoItems && item is MusicVideo)
{
writer.WriteString("object.item.videoItem.musicVideoClip");
}
else
{
writer.WriteString("object.item.videoItem");
}
}
else if (item is MusicGenre)
{
writer.WriteString(_profile.RequiresPlainFolders ? "object.container.storageFolder" : "object.container.genre.musicGenre");
}
else if (item is Genre || item is GameGenre)
{
writer.WriteString(_profile.RequiresPlainFolders ? "object.container.storageFolder" : "object.container.genre");
}
else
{
writer.WriteString("object.item");
}
writer.WriteFullEndElement();
}
/// <summary>
/// Adds fields used by both items and folders
/// </summary>
private void AddCommonFields(BaseItem item, StubType?itemStubType, BaseItem context, XmlWriter writer, Filter filter)
{
// Don't filter on dc:title because not all devices will include it in the filter
// MediaMonkey for example won't display content without a title
//if (filter.Contains("dc:title"))
{
AddValue(writer, "dc", "title", GetDisplayName(item, itemStubType, context), NS_DC);
}
WriteObjectClass(writer, item, itemStubType);
if (filter.Contains("dc:date"))
{
if (item.PremiereDate.HasValue)
{
AddValue(writer, "dc", "date", item.PremiereDate.Value.ToString("o"), NS_DC);
}
}
if (filter.Contains("upnp:genre"))
{
foreach (var genre in item.Genres)
{
AddValue(writer, "upnp", "genre", genre, NS_UPNP);
}
}
foreach (var studio in item.Studios)
{
AddValue(writer, "upnp", "publisher", studio, NS_UPNP);
}
if (filter.Contains("dc:description"))
{
var desc = item.Overview;
if (!string.IsNullOrWhiteSpace(desc))
{
AddValue(writer, "dc", "description", desc, NS_DC);
}
}
if (filter.Contains("upnp:longDescription"))
{
if (!string.IsNullOrWhiteSpace(item.Overview))
{
AddValue(writer, "upnp", "longDescription", item.Overview, NS_UPNP);
}
}
if (!string.IsNullOrEmpty(item.OfficialRating))
{
if (filter.Contains("dc:rating"))
{
AddValue(writer, "dc", "rating", item.OfficialRating, NS_DC);
}
if (filter.Contains("upnp:rating"))
{
AddValue(writer, "upnp", "rating", item.OfficialRating, NS_UPNP);
}
}
AddPeople(item, writer);
}
private string GetDisplayName(BaseItem item, StubType?itemStubType, BaseItem context)
{
if (itemStubType.HasValue && itemStubType.Value == StubType.Latest)
{
return(_localization.GetLocalizedString("ViewTypeMusicLatest"));
}
if (itemStubType.HasValue && itemStubType.Value == StubType.Playlists)
{
return(_localization.GetLocalizedString("ViewTypeMusicPlaylists"));
}
if (itemStubType.HasValue && itemStubType.Value == StubType.AlbumArtists)
{
return(_localization.GetLocalizedString("ViewTypeMusicAlbumArtists"));
}
if (itemStubType.HasValue && itemStubType.Value == StubType.Albums)
{
return(_localization.GetLocalizedString("ViewTypeMusicAlbums"));
}
if (itemStubType.HasValue && itemStubType.Value == StubType.Artists)
{
return(_localization.GetLocalizedString("ViewTypeMusicArtists"));
}
if (itemStubType.HasValue && itemStubType.Value == StubType.Songs)
{
return(_localization.GetLocalizedString("ViewTypeMusicSongs"));
}
if (itemStubType.HasValue && itemStubType.Value == StubType.Genres)
{
return(_localization.GetLocalizedString("ViewTypeTvGenres"));
}
if (itemStubType.HasValue && itemStubType.Value == StubType.FavoriteAlbums)
{
return(_localization.GetLocalizedString("ViewTypeMusicFavoriteAlbums"));
}
if (itemStubType.HasValue && itemStubType.Value == StubType.FavoriteArtists)
{
return(_localization.GetLocalizedString("ViewTypeMusicFavoriteArtists"));
}
if (itemStubType.HasValue && itemStubType.Value == StubType.FavoriteSongs)
{
return(_localization.GetLocalizedString("ViewTypeMusicFavoriteSongs"));
}
if (itemStubType.HasValue && itemStubType.Value == StubType.ContinueWatching)
{
return(_localization.GetLocalizedString("ViewTypeMovieResume"));
}
if (itemStubType.HasValue && itemStubType.Value == StubType.Movies)
{
return(_localization.GetLocalizedString("ViewTypeMovieMovies"));
}
if (itemStubType.HasValue && itemStubType.Value == StubType.Collections)
{
return(_localization.GetLocalizedString("ViewTypeMovieCollections"));
}
if (itemStubType.HasValue && itemStubType.Value == StubType.Favorites)
{
return(_localization.GetLocalizedString("ViewTypeMovieFavorites"));
}
if (itemStubType.HasValue && itemStubType.Value == StubType.NextUp)
{
return(_localization.GetLocalizedString("ViewTypeTvNextUp"));
}
if (itemStubType.HasValue && itemStubType.Value == StubType.FavoriteSeries)
{
return(_localization.GetLocalizedString("ViewTypeTvFavoriteSeries"));
}
if (itemStubType.HasValue && itemStubType.Value == StubType.FavoriteEpisodes)
{
return(_localization.GetLocalizedString("ViewTypeTvFavoriteEpisodes"));
}
if (itemStubType.HasValue && itemStubType.Value == StubType.Series)
{
return(_localization.GetLocalizedString("ViewTypeTvShowSeries"));
}
var episode = item as Episode;
var season = context as Season;
if (episode != null && season != null)
{
// This is a special embedded within a season
if (item.ParentIndexNumber.HasValue && item.ParentIndexNumber.Value == 0)
{
if (season.IndexNumber.HasValue && season.IndexNumber.Value != 0)
{
return(string.Format(_localization.GetLocalizedString("ValueSpecialEpisodeName"), item.Name));
}
}
if (item.IndexNumber.HasValue)
{
var number = item.IndexNumber.Value.ToString("00", CultureInfo.InvariantCulture);
if (episode.IndexNumberEnd.HasValue)
{
number += "-" + episode.IndexNumberEnd.Value.ToString("00", CultureInfo.InvariantCulture);
}
return(number + " - " + item.Name);
}
}
return(item.Name);
}
public static string GetClientId(BaseItem item, StubType?stubType)
{
return(GetClientId(item.Id, stubType));
}
private string GetDisplayName(BaseItem item, StubType?itemStubType, BaseItem context)
{
if (itemStubType.HasValue)
{
switch (itemStubType.Value)
{
case StubType.Latest: return(_localization.GetLocalizedString("Latest"));
case StubType.Playlists: return(_localization.GetLocalizedString("Playlists"));
case StubType.AlbumArtists: return(_localization.GetLocalizedString("HeaderAlbumArtists"));
case StubType.Albums: return(_localization.GetLocalizedString("Albums"));
case StubType.Artists: return(_localization.GetLocalizedString("Artists"));
case StubType.Songs: return(_localization.GetLocalizedString("Songs"));
case StubType.Genres: return(_localization.GetLocalizedString("Genres"));
case StubType.FavoriteAlbums: return(_localization.GetLocalizedString("HeaderFavoriteAlbums"));
case StubType.FavoriteArtists: return(_localization.GetLocalizedString("HeaderFavoriteArtists"));
case StubType.FavoriteSongs: return(_localization.GetLocalizedString("HeaderFavoriteSongs"));
case StubType.ContinueWatching: return(_localization.GetLocalizedString("HeaderContinueWatching"));
case StubType.Movies: return(_localization.GetLocalizedString("Movies"));
case StubType.Collections: return(_localization.GetLocalizedString("Collections"));
case StubType.Favorites: return(_localization.GetLocalizedString("Favorites"));
case StubType.NextUp: return(_localization.GetLocalizedString("HeaderNextUp"));
case StubType.FavoriteSeries: return(_localization.GetLocalizedString("HeaderFavoriteShows"));
case StubType.FavoriteEpisodes: return(_localization.GetLocalizedString("HeaderFavoriteEpisodes"));
case StubType.Series: return(_localization.GetLocalizedString("Shows"));
default: break;
}
}
if (item is Episode episode && context is Season season)
{
// This is a special embedded within a season
if (item.ParentIndexNumber.HasValue && item.ParentIndexNumber.Value == 0 &&
season.IndexNumber.HasValue && season.IndexNumber.Value != 0)
{
return(string.Format(
CultureInfo.InvariantCulture,
_localization.GetLocalizedString("ValueSpecialEpisodeName"),
item.Name));
}
if (item.IndexNumber.HasValue)
{
var number = item.IndexNumber.Value.ToString("00", CultureInfo.InvariantCulture);
if (episode.IndexNumberEnd.HasValue)
{
number += "-" + episode.IndexNumberEnd.Value.ToString("00", CultureInfo.InvariantCulture);
}
return(number + " - " + item.Name);
}
}
private QueryResult <ServerItem> GetTvFolders(BaseItem item, User user, StubType?stubType, SortCriteria sort, int?startIndex, int?limit)
{
var query = new InternalItemsQuery(user)
{
StartIndex = startIndex,
Limit = limit
};
SetSorting(query, sort, false);
if (stubType.HasValue && stubType.Value == StubType.ContinueWatching)
{
return(GetMovieContinueWatching(item, user, query));
}
if (stubType.HasValue && stubType.Value == StubType.NextUp)
{
return(GetNextUp(item, user, query));
}
if (stubType.HasValue && stubType.Value == StubType.Latest)
{
return(GetTvLatest(item, user, query));
}
if (stubType.HasValue && stubType.Value == StubType.Series)
{
return(GetSeries(item, user, query));
}
if (stubType.HasValue && stubType.Value == StubType.FavoriteSeries)
{
return(GetFavoriteSeries(item, user, query));
}
if (stubType.HasValue && stubType.Value == StubType.FavoriteEpisodes)
{
return(GetFavoriteEpisodes(item, user, query));
}
if (stubType.HasValue && stubType.Value == StubType.Genres)
{
return(GetGenres(item, user, query));
}
var list = new List <ServerItem>();
list.Add(new ServerItem(item)
{
StubType = StubType.ContinueWatching
});
list.Add(new ServerItem(item)
{
StubType = StubType.NextUp
});
list.Add(new ServerItem(item)
{
StubType = StubType.Latest
});
list.Add(new ServerItem(item)
{
StubType = StubType.Series
});
list.Add(new ServerItem(item)
{
StubType = StubType.FavoriteSeries
});
list.Add(new ServerItem(item)
{
StubType = StubType.FavoriteEpisodes
});
list.Add(new ServerItem(item)
{
StubType = StubType.Genres
});
return(new QueryResult <ServerItem>
{
Items = list.ToArray(list.Count),
TotalRecordCount = list.Count
});
}
private QueryResult <ServerItem> GetMusicFolders(BaseItem item, User user, StubType?stubType, SortCriteria sort, int?startIndex, int?limit)
{
var query = new InternalItemsQuery(user)
{
StartIndex = startIndex,
Limit = limit
};
SetSorting(query, sort, false);
if (stubType.HasValue && stubType.Value == StubType.Latest)
{
return(GetMusicLatest(item, user, query));
}
if (stubType.HasValue && stubType.Value == StubType.Playlists)
{
return(GetMusicPlaylists(item, user, query));
}
if (stubType.HasValue && stubType.Value == StubType.Albums)
{
return(GetMusicAlbums(item, user, query));
}
if (stubType.HasValue && stubType.Value == StubType.Artists)
{
return(GetMusicArtists(item, user, query));
}
if (stubType.HasValue && stubType.Value == StubType.AlbumArtists)
{
return(GetMusicAlbumArtists(item, user, query));
}
if (stubType.HasValue && stubType.Value == StubType.FavoriteAlbums)
{
return(GetFavoriteAlbums(item, user, query));
}
if (stubType.HasValue && stubType.Value == StubType.FavoriteArtists)
{
return(GetFavoriteArtists(item, user, query));
}
if (stubType.HasValue && stubType.Value == StubType.FavoriteSongs)
{
return(GetFavoriteSongs(item, user, query));
}
if (stubType.HasValue && stubType.Value == StubType.Songs)
{
return(GetMusicSongs(item, user, query));
}
if (stubType.HasValue && stubType.Value == StubType.Genres)
{
return(GetMusicGenres(item, user, query));
}
var list = new List <ServerItem>();
list.Add(new ServerItem(item)
{
StubType = StubType.Latest
});
list.Add(new ServerItem(item)
{
StubType = StubType.Playlists
});
list.Add(new ServerItem(item)
{
StubType = StubType.Albums
});
list.Add(new ServerItem(item)
{
StubType = StubType.AlbumArtists
});
list.Add(new ServerItem(item)
{
StubType = StubType.Artists
});
list.Add(new ServerItem(item)
{
StubType = StubType.Songs
});
list.Add(new ServerItem(item)
{
StubType = StubType.Genres
});
list.Add(new ServerItem(item)
{
StubType = StubType.FavoriteArtists
});
list.Add(new ServerItem(item)
{
StubType = StubType.FavoriteAlbums
});
list.Add(new ServerItem(item)
{
StubType = StubType.FavoriteSongs
});
return(new QueryResult <ServerItem>
{
Items = list.ToArray(list.Count),
TotalRecordCount = list.Count
});
}
private QueryResult <ServerItem> GetUserItems(BaseItem item, StubType?stubType, User user, SortCriteria sort, int?startIndex, int?limit)
{
if (item is MusicGenre)
{
return(GetMusicGenreItems(item, null, user, sort, startIndex, limit));
}
if (item is MusicArtist)
{
return(GetMusicArtistItems(item, null, user, sort, startIndex, limit));
}
if (item is Genre)
{
return(GetGenreItems(item, null, user, sort, startIndex, limit));
}
var collectionFolder = item as ICollectionFolder;
if (collectionFolder != null && string.Equals(CollectionType.Music, collectionFolder.CollectionType, StringComparison.OrdinalIgnoreCase))
{
return(GetMusicFolders(item, user, stubType, sort, startIndex, limit));
}
if (collectionFolder != null && string.Equals(CollectionType.Movies, collectionFolder.CollectionType, StringComparison.OrdinalIgnoreCase))
{
return(GetMovieFolders(item, user, stubType, sort, startIndex, limit));
}
if (collectionFolder != null && string.Equals(CollectionType.TvShows, collectionFolder.CollectionType, StringComparison.OrdinalIgnoreCase))
{
return(GetTvFolders(item, user, stubType, sort, startIndex, limit));
}
if (stubType.HasValue)
{
var person = item as Person;
if (person != null)
{
return(GetItemsFromPerson(person, user, startIndex, limit));
}
return(ApplyPaging(new QueryResult <ServerItem>(), startIndex, limit));
}
var folder = (Folder)item;
var query = new InternalItemsQuery
{
Limit = limit,
StartIndex = startIndex,
User = user,
IsVirtualItem = false,
PresetViews = new string[] { },
ExcludeItemTypes = new[] { typeof(Game).Name, typeof(Book).Name },
IsPlaceHolder = false,
DtoOptions = GetDtoOptions()
};
SetSorting(query, sort, folder.IsPreSorted);
var queryResult = folder.GetItems(query);
return(ToResult(queryResult));
}
private QueryResult <ServerItem> GetUserItems(BaseItem item, StubType?stubType, User user, SortCriteria sort, int?startIndex, int?limit)
{
if (item is MusicGenre)
{
return(GetMusicGenreItems(item, Guid.Empty, user, sort, startIndex, limit));
}
if (item is MusicArtist)
{
return(GetMusicArtistItems(item, Guid.Empty, user, sort, startIndex, limit));
}
if (item is Genre)
{
return(GetGenreItems(item, Guid.Empty, user, sort, startIndex, limit));
}
if ((!stubType.HasValue || stubType.Value != StubType.Folder) &&
item is IHasCollectionType collectionFolder)
{
if (string.Equals(CollectionType.Music, collectionFolder.CollectionType, StringComparison.OrdinalIgnoreCase))
{
return(GetMusicFolders(item, user, stubType, sort, startIndex, limit));
}
else if (string.Equals(CollectionType.Movies, collectionFolder.CollectionType, StringComparison.OrdinalIgnoreCase))
{
return(GetMovieFolders(item, user, stubType, sort, startIndex, limit));
}
else if (string.Equals(CollectionType.TvShows, collectionFolder.CollectionType, StringComparison.OrdinalIgnoreCase))
{
return(GetTvFolders(item, user, stubType, sort, startIndex, limit));
}
else if (string.Equals(CollectionType.Folders, collectionFolder.CollectionType, StringComparison.OrdinalIgnoreCase))
{
return(GetFolders(item, user, stubType, sort, startIndex, limit));
}
else if (string.Equals(CollectionType.LiveTv, collectionFolder.CollectionType, StringComparison.OrdinalIgnoreCase))
{
return(GetLiveTvChannels(item, user, stubType, sort, startIndex, limit));
}
}
if (stubType.HasValue)
{
if (stubType.Value != StubType.Folder)
{
return(ApplyPaging(new QueryResult <ServerItem>(), startIndex, limit));
}
}
var folder = (Folder)item;
var query = new InternalItemsQuery(user)
{
Limit = limit,
StartIndex = startIndex,
IsVirtualItem = false,
ExcludeItemTypes = new[] { typeof(Book).Name },
IsPlaceHolder = false,
DtoOptions = GetDtoOptions()
};
SetSorting(query, sort, folder.IsPreSorted);
var queryResult = folder.GetItems(query);
return(ToResult(queryResult));
}
