public async Task <object> Get(GetLiveMediaInfo request)
{
var item = _libraryManager.GetItemById(request.Id);
IEnumerable <MediaSourceInfo> mediaSources;
var channelItem = item as IChannelMediaItem;
var user = _userManager.GetUserById(request.UserId);
if (channelItem != null)
{
mediaSources = await _channelManager.GetChannelItemMediaSources(request.Id, true, CancellationToken.None)
.ConfigureAwait(false);
}
else
{
var hasMediaSources = (IHasMediaSources)item;
if (user == null)
{
mediaSources = hasMediaSources.GetMediaSources(true);
}
else
{
mediaSources = hasMediaSources.GetMediaSources(true, user);
}
}
return(ToOptimizedResult(new LiveMediaInfoResult
{
MediaSources = mediaSources.ToList()
}));
}
private async Task DownloadChannelItem(BaseItem item,
ChannelOptions channelOptions,
CancellationToken cancellationToken,
string path)
{
var limit = GetDownloadLimit(channelOptions);
if (limit.HasValue)
{
if (IsSizeLimitReached(path, limit.Value))
{
return;
}
}
var itemId = item.Id.ToString("N");
var sources = await _manager.GetChannelItemMediaSources(itemId, cancellationToken)
.ConfigureAwait(false);
var list = sources.ToList();
var cachedVersions = list.Where(i => i.Protocol == MediaProtocol.File).ToList();
if (cachedVersions.Count > 0)
{
await RefreshMediaSourceItems(cachedVersions, cancellationToken).ConfigureAwait(false);
return;
}
var source = list.FirstOrDefault(i => i.Protocol == MediaProtocol.Http);
if (source == null)
{
return;
}
var channelItem = (IChannelMediaItem)item;
var destination = Path.Combine(path, channelItem.ChannelId, itemId);
await _manager.DownloadChannelItem(channelItem, destination, new Progress <double>(), cancellationToken)
.ConfigureAwait(false);
await RefreshMediaSourceItem(destination, cancellationToken).ConfigureAwait(false);
}
public async Task <IEnumerable <MediaSourceInfo> > GetPlayackMediaSources(string id, string userId, bool enablePathSubstitution, CancellationToken cancellationToken)
{
var item = _libraryManager.GetItemById(id);
IEnumerable <MediaSourceInfo> mediaSources;
var hasMediaSources = (IHasMediaSources)item;
var channelItem = item as IChannelMediaItem;
if (channelItem != null)
{
mediaSources = await _channelManager.GetChannelItemMediaSources(id, true, cancellationToken)
.ConfigureAwait(false);
}
else
{
if (string.IsNullOrWhiteSpace(userId))
{
mediaSources = hasMediaSources.GetMediaSources(enablePathSubstitution);
}
else
{
var user = _userManager.GetUserById(userId);
mediaSources = GetStaticMediaSources(hasMediaSources, enablePathSubstitution, user);
}
}
var dynamicMediaSources = await GetDynamicMediaSources(hasMediaSources, cancellationToken).ConfigureAwait(false);
var list = new List <MediaSourceInfo>();
list.AddRange(mediaSources);
foreach (var source in dynamicMediaSources)
{
source.SupportsTranscoding = false;
if (source.Protocol == MediaProtocol.File)
{
source.SupportsDirectStream = File.Exists(source.Path);
}
list.Add(source);
}
return(SortMediaSources(list));
}
private async Task <MediaSourceInfo> GetChannelMediaInfo(string id,
string mediaSourceId,
CancellationToken cancellationToken)
{
var channelMediaSources = await _channelManager.GetChannelItemMediaSources(id, true, cancellationToken)
.ConfigureAwait(false);
var list = channelMediaSources.ToList();
if (!string.IsNullOrWhiteSpace(mediaSourceId))
{
var source = list
.FirstOrDefault(i => string.Equals(mediaSourceId, i.Id));
if (source != null)
{
return(source);
}
}
return(list.First());
}
private async Task DownloadChannelItem(BaseItemDto item,
ChannelOptions channelOptions,
CancellationToken cancellationToken,
string path)
{
if (channelOptions.DownloadSizeLimit.HasValue)
{
if (IsSizeLimitReached(path, channelOptions.DownloadSizeLimit.Value))
{
return;
}
}
var sources = await _manager.GetChannelItemMediaSources(item.Id, cancellationToken)
.ConfigureAwait(false);
var list = sources.ToList();
var cachedVersions = list.Where(i => i.Protocol == MediaProtocol.File).ToList();
if (cachedVersions.Count > 0)
{
await RefreshMediaSourceItems(cachedVersions, cancellationToken).ConfigureAwait(false);
return;
}
var source = list.FirstOrDefault(i => i.Protocol == MediaProtocol.Http);
if (source == null)
{
return;
}
var options = new HttpRequestOptions
{
CancellationToken = cancellationToken,
Url = source.Path,
Progress = new Progress <double>()
};
foreach (var header in source.RequiredHttpHeaders)
{
options.RequestHeaders[header.Key] = header.Value;
}
var destination = Path.Combine(path, item.ChannelId, item.Id);
Directory.CreateDirectory(Path.GetDirectoryName(destination));
// Determine output extension
var response = await _httpClient.GetTempFileResponse(options).ConfigureAwait(false);
if (item.IsVideo && response.ContentType.StartsWith("video/", StringComparison.OrdinalIgnoreCase))
{
var extension = response.ContentType.Split('/')
.Last()
.Replace("quicktime", "mov", StringComparison.OrdinalIgnoreCase);
destination += "." + extension;
}
else if (item.IsAudio && response.ContentType.StartsWith("audio/", StringComparison.OrdinalIgnoreCase))
{
var extension = response.ContentType.Replace("audio/mpeg", "audio/mp3", StringComparison.OrdinalIgnoreCase)
.Split('/')
.Last();
destination += "." + extension;
}
else
{
File.Delete(response.TempFilePath);
throw new ApplicationException("Unexpected response type encountered: " + response.ContentType);
}
File.Copy(response.TempFilePath, destination, true);
await RefreshMediaSourceItem(destination, cancellationToken).ConfigureAwait(false);
try
{
File.Delete(response.TempFilePath);
}
catch
{
}
}
