You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1238 lines
44 KiB
1238 lines
44 KiB
#nullable disable
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text.Json;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using Jellyfin.Data.Entities;
|
|
using Jellyfin.Data.Enums;
|
|
using Jellyfin.Extensions;
|
|
using Jellyfin.Extensions.Json;
|
|
using MediaBrowser.Common.Extensions;
|
|
using MediaBrowser.Common.Progress;
|
|
using MediaBrowser.Controller.Channels;
|
|
using MediaBrowser.Controller.Configuration;
|
|
using MediaBrowser.Controller.Dto;
|
|
using MediaBrowser.Controller.Entities;
|
|
using MediaBrowser.Controller.Entities.Audio;
|
|
using MediaBrowser.Controller.Library;
|
|
using MediaBrowser.Controller.Providers;
|
|
using MediaBrowser.Model.Channels;
|
|
using MediaBrowser.Model.Dto;
|
|
using MediaBrowser.Model.Entities;
|
|
using MediaBrowser.Model.IO;
|
|
using MediaBrowser.Model.Querying;
|
|
using Microsoft.Extensions.Caching.Memory;
|
|
using Microsoft.Extensions.Logging;
|
|
using Episode = MediaBrowser.Controller.Entities.TV.Episode;
|
|
using Movie = MediaBrowser.Controller.Entities.Movies.Movie;
|
|
using MusicAlbum = MediaBrowser.Controller.Entities.Audio.MusicAlbum;
|
|
using Season = MediaBrowser.Controller.Entities.TV.Season;
|
|
using Series = MediaBrowser.Controller.Entities.TV.Series;
|
|
|
|
namespace Emby.Server.Implementations.Channels
|
|
{
|
|
/// <summary>
|
|
/// The LiveTV channel manager.
|
|
/// </summary>
|
|
public class ChannelManager : IChannelManager, IDisposable
|
|
{
|
|
private readonly IUserManager _userManager;
|
|
private readonly IUserDataManager _userDataManager;
|
|
private readonly IDtoService _dtoService;
|
|
private readonly ILibraryManager _libraryManager;
|
|
private readonly ILogger<ChannelManager> _logger;
|
|
private readonly IServerConfigurationManager _config;
|
|
private readonly IFileSystem _fileSystem;
|
|
private readonly IProviderManager _providerManager;
|
|
private readonly IMemoryCache _memoryCache;
|
|
private readonly SemaphoreSlim _resourcePool = new SemaphoreSlim(1, 1);
|
|
private readonly JsonSerializerOptions _jsonOptions = JsonDefaults.Options;
|
|
private bool _disposed = false;
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the <see cref="ChannelManager"/> class.
|
|
/// </summary>
|
|
/// <param name="userManager">The user manager.</param>
|
|
/// <param name="dtoService">The dto service.</param>
|
|
/// <param name="libraryManager">The library manager.</param>
|
|
/// <param name="logger">The logger.</param>
|
|
/// <param name="config">The server configuration manager.</param>
|
|
/// <param name="fileSystem">The filesystem.</param>
|
|
/// <param name="userDataManager">The user data manager.</param>
|
|
/// <param name="providerManager">The provider manager.</param>
|
|
/// <param name="memoryCache">The memory cache.</param>
|
|
/// <param name="channels">The channels.</param>
|
|
public ChannelManager(
|
|
IUserManager userManager,
|
|
IDtoService dtoService,
|
|
ILibraryManager libraryManager,
|
|
ILogger<ChannelManager> logger,
|
|
IServerConfigurationManager config,
|
|
IFileSystem fileSystem,
|
|
IUserDataManager userDataManager,
|
|
IProviderManager providerManager,
|
|
IMemoryCache memoryCache,
|
|
IEnumerable<IChannel> channels)
|
|
{
|
|
_userManager = userManager;
|
|
_dtoService = dtoService;
|
|
_libraryManager = libraryManager;
|
|
_logger = logger;
|
|
_config = config;
|
|
_fileSystem = fileSystem;
|
|
_userDataManager = userDataManager;
|
|
_providerManager = providerManager;
|
|
_memoryCache = memoryCache;
|
|
Channels = channels.ToArray();
|
|
}
|
|
|
|
internal IChannel[] Channels { get; }
|
|
|
|
private static TimeSpan CacheLength => TimeSpan.FromHours(3);
|
|
|
|
/// <inheritdoc />
|
|
public bool EnableMediaSourceDisplay(BaseItem item)
|
|
{
|
|
var internalChannel = _libraryManager.GetItemById(item.ChannelId);
|
|
var channel = Channels.FirstOrDefault(i => GetInternalChannelId(i.Name).Equals(internalChannel.Id));
|
|
|
|
return channel is not IDisableMediaSourceDisplay;
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public bool CanDelete(BaseItem item)
|
|
{
|
|
var internalChannel = _libraryManager.GetItemById(item.ChannelId);
|
|
var channel = Channels.FirstOrDefault(i => GetInternalChannelId(i.Name).Equals(internalChannel.Id));
|
|
|
|
return channel is ISupportsDelete supportsDelete && supportsDelete.CanDelete(item);
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public bool EnableMediaProbe(BaseItem item)
|
|
{
|
|
var internalChannel = _libraryManager.GetItemById(item.ChannelId);
|
|
var channel = Channels.FirstOrDefault(i => GetInternalChannelId(i.Name).Equals(internalChannel.Id));
|
|
|
|
return channel is ISupportsMediaProbe;
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public Task DeleteItem(BaseItem item)
|
|
{
|
|
var internalChannel = _libraryManager.GetItemById(item.ChannelId);
|
|
if (internalChannel is null)
|
|
{
|
|
throw new ArgumentException(nameof(item.ChannelId));
|
|
}
|
|
|
|
var channel = Channels.FirstOrDefault(i => GetInternalChannelId(i.Name).Equals(internalChannel.Id));
|
|
|
|
if (channel is not ISupportsDelete supportsDelete)
|
|
{
|
|
throw new ArgumentException(nameof(channel));
|
|
}
|
|
|
|
return supportsDelete.DeleteItem(item.ExternalId, CancellationToken.None);
|
|
}
|
|
|
|
private IEnumerable<IChannel> GetAllChannels()
|
|
{
|
|
return Channels
|
|
.OrderBy(i => i.Name);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the installed channel IDs.
|
|
/// </summary>
|
|
/// <returns>An <see cref="IEnumerable{T}"/> containing installed channel IDs.</returns>
|
|
public IEnumerable<Guid> GetInstalledChannelIds()
|
|
{
|
|
return GetAllChannels().Select(i => GetInternalChannelId(i.Name));
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public QueryResult<Channel> GetChannelsInternal(ChannelQuery query)
|
|
{
|
|
var user = query.UserId.Equals(default)
|
|
? null
|
|
: _userManager.GetUserById(query.UserId);
|
|
|
|
var channels = GetAllChannels()
|
|
.Select(GetChannelEntity)
|
|
.OrderBy(i => i.SortName)
|
|
.ToList();
|
|
|
|
if (query.IsRecordingsFolder.HasValue)
|
|
{
|
|
var val = query.IsRecordingsFolder.Value;
|
|
channels = channels.Where(i =>
|
|
{
|
|
try
|
|
{
|
|
return (GetChannelProvider(i) is IHasFolderAttributes hasAttributes
|
|
&& hasAttributes.Attributes.Contains("Recordings", StringComparison.OrdinalIgnoreCase)) == val;
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}).ToList();
|
|
}
|
|
|
|
if (query.SupportsLatestItems.HasValue)
|
|
{
|
|
var val = query.SupportsLatestItems.Value;
|
|
channels = channels.Where(i =>
|
|
{
|
|
try
|
|
{
|
|
return GetChannelProvider(i) is ISupportsLatestMedia == val;
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}).ToList();
|
|
}
|
|
|
|
if (query.SupportsMediaDeletion.HasValue)
|
|
{
|
|
var val = query.SupportsMediaDeletion.Value;
|
|
channels = channels.Where(i =>
|
|
{
|
|
try
|
|
{
|
|
return GetChannelProvider(i) is ISupportsDelete == val;
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}).ToList();
|
|
}
|
|
|
|
if (query.IsFavorite.HasValue)
|
|
{
|
|
var val = query.IsFavorite.Value;
|
|
channels = channels.Where(i => _userDataManager.GetUserData(user, i).IsFavorite == val)
|
|
.ToList();
|
|
}
|
|
|
|
if (user is not null)
|
|
{
|
|
channels = channels.Where(i =>
|
|
{
|
|
if (!i.IsVisible(user))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
try
|
|
{
|
|
return GetChannelProvider(i).IsEnabledFor(user.Id.ToString("N", CultureInfo.InvariantCulture));
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}).ToList();
|
|
}
|
|
|
|
var all = channels;
|
|
var totalCount = all.Count;
|
|
|
|
if (query.StartIndex.HasValue || query.Limit.HasValue)
|
|
{
|
|
int startIndex = query.StartIndex ?? 0;
|
|
int count = query.Limit is null ? totalCount - startIndex : Math.Min(query.Limit.Value, totalCount - startIndex);
|
|
all = all.GetRange(startIndex, count);
|
|
}
|
|
|
|
if (query.RefreshLatestChannelItems)
|
|
{
|
|
foreach (var item in all)
|
|
{
|
|
RefreshLatestChannelItems(GetChannelProvider(item), CancellationToken.None).GetAwaiter().GetResult();
|
|
}
|
|
}
|
|
|
|
return new QueryResult<Channel>(
|
|
query.StartIndex,
|
|
totalCount,
|
|
all);
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public QueryResult<BaseItemDto> GetChannels(ChannelQuery query)
|
|
{
|
|
var user = query.UserId.Equals(default)
|
|
? null
|
|
: _userManager.GetUserById(query.UserId);
|
|
|
|
var internalResult = GetChannelsInternal(query);
|
|
|
|
var dtoOptions = new DtoOptions();
|
|
|
|
// TODO Fix The co-variant conversion (internalResult.Items) between Folder[] and BaseItem[], this can generate runtime issues.
|
|
var returnItems = _dtoService.GetBaseItemDtos(internalResult.Items, dtoOptions, user);
|
|
|
|
var result = new QueryResult<BaseItemDto>(
|
|
query.StartIndex,
|
|
internalResult.TotalRecordCount,
|
|
returnItems);
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Refreshes the associated channels.
|
|
/// </summary>
|
|
/// <param name="progress">The progress.</param>
|
|
/// <param name="cancellationToken">A cancellation token that can be used to cancel the operation.</param>
|
|
/// <returns>The completed task.</returns>
|
|
public async Task RefreshChannels(IProgress<double> progress, CancellationToken cancellationToken)
|
|
{
|
|
var allChannelsList = GetAllChannels().ToList();
|
|
|
|
var numComplete = 0;
|
|
|
|
foreach (var channelInfo in allChannelsList)
|
|
{
|
|
cancellationToken.ThrowIfCancellationRequested();
|
|
|
|
try
|
|
{
|
|
await GetChannel(channelInfo, cancellationToken).ConfigureAwait(false);
|
|
}
|
|
catch (OperationCanceledException)
|
|
{
|
|
throw;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Error getting channel information for {0}", channelInfo.Name);
|
|
}
|
|
|
|
numComplete++;
|
|
double percent = (double)numComplete / allChannelsList.Count;
|
|
progress.Report(100 * percent);
|
|
}
|
|
|
|
progress.Report(100);
|
|
}
|
|
|
|
private Channel GetChannelEntity(IChannel channel)
|
|
{
|
|
return GetChannel(GetInternalChannelId(channel.Name)) ?? GetChannel(channel, CancellationToken.None).GetAwaiter().GetResult();
|
|
}
|
|
|
|
private MediaSourceInfo[] GetSavedMediaSources(BaseItem item)
|
|
{
|
|
var path = Path.Combine(item.GetInternalMetadataPath(), "channelmediasourceinfos.json");
|
|
|
|
try
|
|
{
|
|
var bytes = File.ReadAllBytes(path);
|
|
return JsonSerializer.Deserialize<MediaSourceInfo[]>(bytes, _jsonOptions)
|
|
?? Array.Empty<MediaSourceInfo>();
|
|
}
|
|
catch
|
|
{
|
|
return Array.Empty<MediaSourceInfo>();
|
|
}
|
|
}
|
|
|
|
private async Task SaveMediaSources(BaseItem item, List<MediaSourceInfo> mediaSources)
|
|
{
|
|
var path = Path.Combine(item.GetInternalMetadataPath(), "channelmediasourceinfos.json");
|
|
|
|
if (mediaSources is null || mediaSources.Count == 0)
|
|
{
|
|
try
|
|
{
|
|
_fileSystem.DeleteFile(path);
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
Directory.CreateDirectory(Path.GetDirectoryName(path));
|
|
|
|
await using FileStream createStream = File.Create(path);
|
|
await JsonSerializer.SerializeAsync(createStream, mediaSources, _jsonOptions).ConfigureAwait(false);
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public IEnumerable<MediaSourceInfo> GetStaticMediaSources(BaseItem item, CancellationToken cancellationToken)
|
|
{
|
|
IEnumerable<MediaSourceInfo> results = GetSavedMediaSources(item);
|
|
|
|
return results
|
|
.Select(i => NormalizeMediaSource(item, i))
|
|
.ToList();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the dynamic media sources based on the provided item.
|
|
/// </summary>
|
|
/// <param name="item">The item.</param>
|
|
/// <param name="cancellationToken">A cancellation token that can be used to cancel the operation.</param>
|
|
/// <returns>The task representing the operation to get the media sources.</returns>
|
|
public async Task<IEnumerable<MediaSourceInfo>> GetDynamicMediaSources(BaseItem item, CancellationToken cancellationToken)
|
|
{
|
|
var channel = GetChannel(item.ChannelId);
|
|
var channelPlugin = GetChannelProvider(channel);
|
|
|
|
IEnumerable<MediaSourceInfo> results;
|
|
|
|
if (channelPlugin is IRequiresMediaInfoCallback requiresCallback)
|
|
{
|
|
results = await GetChannelItemMediaSourcesInternal(requiresCallback, item.ExternalId, cancellationToken)
|
|
.ConfigureAwait(false);
|
|
}
|
|
else
|
|
{
|
|
results = new List<MediaSourceInfo>();
|
|
}
|
|
|
|
return results
|
|
.Select(i => NormalizeMediaSource(item, i))
|
|
.ToList();
|
|
}
|
|
|
|
private async Task<IEnumerable<MediaSourceInfo>> GetChannelItemMediaSourcesInternal(IRequiresMediaInfoCallback channel, string id, CancellationToken cancellationToken)
|
|
{
|
|
if (_memoryCache.TryGetValue(id, out List<MediaSourceInfo> cachedInfo))
|
|
{
|
|
return cachedInfo;
|
|
}
|
|
|
|
var mediaInfo = await channel.GetChannelItemMediaInfo(id, cancellationToken)
|
|
.ConfigureAwait(false);
|
|
var list = mediaInfo.ToList();
|
|
_memoryCache.Set(id, list, DateTimeOffset.UtcNow.AddMinutes(5));
|
|
|
|
return list;
|
|
}
|
|
|
|
private static MediaSourceInfo NormalizeMediaSource(BaseItem item, MediaSourceInfo info)
|
|
{
|
|
info.RunTimeTicks ??= item.RunTimeTicks;
|
|
|
|
return info;
|
|
}
|
|
|
|
private async Task<Channel> GetChannel(IChannel channelInfo, CancellationToken cancellationToken)
|
|
{
|
|
var parentFolderId = Guid.Empty;
|
|
|
|
var id = GetInternalChannelId(channelInfo.Name);
|
|
|
|
var path = Channel.GetInternalMetadataPath(_config.ApplicationPaths.InternalMetadataPath, id);
|
|
|
|
var isNew = false;
|
|
var forceUpdate = false;
|
|
|
|
var item = _libraryManager.GetItemById(id) as Channel;
|
|
|
|
if (item is null)
|
|
{
|
|
item = new Channel
|
|
{
|
|
Name = channelInfo.Name,
|
|
Id = id,
|
|
DateCreated = _fileSystem.GetCreationTimeUtc(path),
|
|
DateModified = _fileSystem.GetLastWriteTimeUtc(path)
|
|
};
|
|
|
|
isNew = true;
|
|
}
|
|
|
|
if (!string.Equals(item.Path, path, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
isNew = true;
|
|
}
|
|
|
|
item.Path = path;
|
|
|
|
if (!item.ChannelId.Equals(id))
|
|
{
|
|
forceUpdate = true;
|
|
}
|
|
|
|
item.ChannelId = id;
|
|
|
|
if (!item.ParentId.Equals(parentFolderId))
|