< Summary - Jellyfin

Information
Class: Jellyfin.LiveTv.Channels.ChannelManager
Assembly: Jellyfin.LiveTv
File(s): /srv/git/jellyfin/src/Jellyfin.LiveTv/Channels/ChannelManager.cs
Line coverage
11%
Covered lines: 65
Uncovered lines: 521
Coverable lines: 586
Total lines: 1215
Line coverage: 11%
Branch coverage
6%
Covered branches: 14
Total branches: 225
Branch coverage: 6.2%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Coverage history

Coverage history 0 25 50 75 100 1/23/2026 - 12:11:06 AM Line coverage: 18.2% (23/126) Branch coverage: 9.7% (4/41) Total lines: 12154/19/2026 - 12:14:27 AM Line coverage: 11% (65/586) Branch coverage: 6.2% (14/225) Total lines: 1215 1/23/2026 - 12:11:06 AM Line coverage: 18.2% (23/126) Branch coverage: 9.7% (4/41) Total lines: 12154/19/2026 - 12:14:27 AM Line coverage: 11% (65/586) Branch coverage: 6.2% (14/225) Total lines: 1215

Coverage delta

Coverage delta 8 -8

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%11100%
get_CacheLength()100%210%
EnableMediaSourceDisplay(...)100%210%
CanDelete(...)0%620%
DeleteItem(...)0%2040%
GetAllChannels()100%11100%
GetInstalledChannelIds()100%210%
GetChannelsInternalAsync()50%621848.78%
GetChannelsAsync()0%620%
RefreshChannels()0%620%
GetAllChannelEntitiesAsync()25%5466.66%
GetSavedMediaSources(...)0%620%
SaveMediaSources()0%2040%
GetStaticMediaSources(...)100%210%
GetDynamicMediaSources()0%620%
GetChannelItemMediaSourcesInternal()0%620%
NormalizeMediaSource(...)0%620%
GetChannel()0%156120%
GetOfficialRating(...)0%3050%
GetChannel(...)100%210%
GetChannel(...)100%210%
GetAllChannelFeatures()100%210%
GetChannelFeatures(...)0%620%
GetChannelFeaturesDto(...)100%210%
GetInternalChannelId(...)100%210%
GetLatestChannelItems()100%210%
GetLatestChannelItemsInternal()0%110100%
RefreshLatestChannelItems()0%2040%
GetChannelItemsInternal()0%210140%
GetChannelItems()100%210%
GetChannelItems()0%210140%
CacheResponse()100%210%
GetChannelDataCachePath(...)0%156120%
GetIdToHash(...)0%620%
GetItemById(...)0%620%
GetChannelItemEntityAsync()0%9312960%
GetChannelProvider(...)0%620%
Dispose()100%11100%
Dispose(...)66.66%6683.33%

File(s)

/srv/git/jellyfin/src/Jellyfin.LiveTv/Channels/ChannelManager.cs

#LineLine coverage
 1#nullable disable
 2
 3using System;
 4using System.Collections.Generic;
 5using System.Globalization;
 6using System.IO;
 7using System.Linq;
 8using System.Text.Json;
 9using System.Threading;
 10using System.Threading.Tasks;
 11using AsyncKeyedLock;
 12using Jellyfin.Data.Enums;
 13using Jellyfin.Database.Implementations.Entities;
 14using Jellyfin.Database.Implementations.Enums;
 15using Jellyfin.Extensions;
 16using Jellyfin.Extensions.Json;
 17using MediaBrowser.Common.Extensions;
 18using MediaBrowser.Controller.Channels;
 19using MediaBrowser.Controller.Configuration;
 20using MediaBrowser.Controller.Dto;
 21using MediaBrowser.Controller.Entities;
 22using MediaBrowser.Controller.Entities.Audio;
 23using MediaBrowser.Controller.Library;
 24using MediaBrowser.Controller.Providers;
 25using MediaBrowser.Model.Channels;
 26using MediaBrowser.Model.Dto;
 27using MediaBrowser.Model.Entities;
 28using MediaBrowser.Model.IO;
 29using MediaBrowser.Model.Querying;
 30using Microsoft.Extensions.Caching.Memory;
 31using Microsoft.Extensions.Logging;
 32using Episode = MediaBrowser.Controller.Entities.TV.Episode;
 33using Movie = MediaBrowser.Controller.Entities.Movies.Movie;
 34using MusicAlbum = MediaBrowser.Controller.Entities.Audio.MusicAlbum;
 35using Season = MediaBrowser.Controller.Entities.TV.Season;
 36using Series = MediaBrowser.Controller.Entities.TV.Series;
 37
 38namespace Jellyfin.LiveTv.Channels
 39{
 40    /// <summary>
 41    /// The LiveTV channel manager.
 42    /// </summary>
 43    public class ChannelManager : IChannelManager, IDisposable
 44    {
 45        private readonly IUserManager _userManager;
 46        private readonly IUserDataManager _userDataManager;
 47        private readonly IDtoService _dtoService;
 48        private readonly ILibraryManager _libraryManager;
 49        private readonly ILogger<ChannelManager> _logger;
 50        private readonly IServerConfigurationManager _config;
 51        private readonly IFileSystem _fileSystem;
 52        private readonly IProviderManager _providerManager;
 53        private readonly IMemoryCache _memoryCache;
 2154        private readonly AsyncNonKeyedLocker _resourcePool = new(1);
 2155        private readonly JsonSerializerOptions _jsonOptions = JsonDefaults.Options;
 56        private bool _disposed = false;
 57
 58        /// <summary>
 59        /// Initializes a new instance of the <see cref="ChannelManager"/> class.
 60        /// </summary>
 61        /// <param name="userManager">The user manager.</param>
 62        /// <param name="dtoService">The dto service.</param>
 63        /// <param name="libraryManager">The library manager.</param>
 64        /// <param name="logger">The logger.</param>
 65        /// <param name="config">The server configuration manager.</param>
 66        /// <param name="fileSystem">The filesystem.</param>
 67        /// <param name="userDataManager">The user data manager.</param>
 68        /// <param name="providerManager">The provider manager.</param>
 69        /// <param name="memoryCache">The memory cache.</param>
 70        /// <param name="channels">The channels.</param>
 71        public ChannelManager(
 72            IUserManager userManager,
 73            IDtoService dtoService,
 74            ILibraryManager libraryManager,
 75            ILogger<ChannelManager> logger,
 76            IServerConfigurationManager config,
 77            IFileSystem fileSystem,
 78            IUserDataManager userDataManager,
 79            IProviderManager providerManager,
 80            IMemoryCache memoryCache,
 81            IEnumerable<IChannel> channels)
 82        {
 2183            _userManager = userManager;
 2184            _dtoService = dtoService;
 2185            _libraryManager = libraryManager;
 2186            _logger = logger;
 2187            _config = config;
 2188            _fileSystem = fileSystem;
 2189            _userDataManager = userDataManager;
 2190            _providerManager = providerManager;
 2191            _memoryCache = memoryCache;
 2192            Channels = channels.ToArray();
 2193        }
 94
 95        internal IChannel[] Channels { get; }
 96
 097        private static TimeSpan CacheLength => TimeSpan.FromHours(3);
 98
 99        /// <inheritdoc />
 100        public bool EnableMediaSourceDisplay(BaseItem item)
 101        {
 0102            var internalChannel = _libraryManager.GetItemById(item.ChannelId);
 0103            var channel = Channels.FirstOrDefault(i => GetInternalChannelId(i.Name).Equals(internalChannel.Id));
 104
 0105            return channel is not IDisableMediaSourceDisplay;
 106        }
 107
 108        /// <inheritdoc />
 109        public bool CanDelete(BaseItem item)
 110        {
 0111            var internalChannel = _libraryManager.GetItemById(item.ChannelId);
 0112            var channel = Channels.FirstOrDefault(i => GetInternalChannelId(i.Name).Equals(internalChannel.Id));
 113
 0114            return channel is ISupportsDelete supportsDelete && supportsDelete.CanDelete(item);
 115        }
 116
 117        /// <inheritdoc />
 118        public Task DeleteItem(BaseItem item)
 119        {
 0120            var internalChannel = _libraryManager.GetItemById(item.ChannelId);
 0121            if (internalChannel is null)
 122            {
 0123                throw new ArgumentException(nameof(item.ChannelId));
 124            }
 125
 0126            var channel = Channels.FirstOrDefault(i => GetInternalChannelId(i.Name).Equals(internalChannel.Id));
 127
 0128            if (channel is not ISupportsDelete supportsDelete)
 129            {
 0130                throw new ArgumentException(nameof(channel));
 131            }
 132
 0133            return supportsDelete.DeleteItem(item.ExternalId, CancellationToken.None);
 134        }
 135
 136        private IEnumerable<IChannel> GetAllChannels()
 137        {
 1138            return Channels
 1139                .OrderBy(i => i.Name);
 140        }
 141
 142        /// <summary>
 143        /// Get the installed channel IDs.
 144        /// </summary>
 145        /// <returns>An <see cref="IEnumerable{T}"/> containing installed channel IDs.</returns>
 146        public IEnumerable<Guid> GetInstalledChannelIds()
 147        {
 0148            return GetAllChannels().Select(i => GetInternalChannelId(i.Name));
 149        }
 150
 151        /// <inheritdoc />
 152        public async Task<QueryResult<Channel>> GetChannelsInternalAsync(ChannelQuery query)
 153        {
 1154            var user = query.UserId.IsEmpty()
 1155                ? null
 1156                : _userManager.GetUserById(query.UserId);
 157
 1158            var channels = await GetAllChannelEntitiesAsync()
 1159                .OrderBy(i => i.SortName)
 1160                .ToListAsync()
 1161                .ConfigureAwait(false);
 162
 1163            if (query.IsRecordingsFolder.HasValue)
 164            {
 0165                var val = query.IsRecordingsFolder.Value;
 0166                channels = channels.Where(i =>
 0167                {
 0168                    try
 0169                    {
 0170                        return (GetChannelProvider(i) is IHasFolderAttributes hasAttributes
 0171                            && hasAttributes.Attributes.Contains("Recordings", StringComparison.OrdinalIgnoreCase)) == v
 0172                    }
 0173                    catch
 0174                    {
 0175                        return false;
 0176                    }
 0177                }).ToList();
 178            }
 179
 1180            if (query.SupportsLatestItems.HasValue)
 181            {
 0182                var val = query.SupportsLatestItems.Value;
 0183                channels = channels.Where(i =>
 0184                {
 0185                    try
 0186                    {
 0187                        return GetChannelProvider(i) is ISupportsLatestMedia == val;
 0188                    }
 0189                    catch
 0190                    {
 0191                        return false;
 0192                    }
 0193                }).ToList();
 194            }
 195
 1196            if (query.SupportsMediaDeletion.HasValue)
 197            {
 0198                var val = query.SupportsMediaDeletion.Value;
 0199                channels = channels.Where(i =>
 0200                {
 0201                    try
 0202                    {
 0203                        return GetChannelProvider(i) is ISupportsDelete == val;
 0204                    }
 0205                    catch
 0206                    {
 0207                        return false;
 0208                    }
 0209                }).ToList();
 210            }
 211
 1212            if (query.IsFavorite.HasValue)
 213            {
 0214                var val = query.IsFavorite.Value;
 0215                channels = channels.Where(i => _userDataManager.GetUserData(user, i).IsFavorite == val)
 0216                    .ToList();
 217            }
 218
 1219            if (user is not null)
 220            {
 1221                var userId = user.Id.ToString("N", CultureInfo.InvariantCulture);
 1222                channels = channels.Where(i =>
 1223                {
 1224                    if (!i.IsVisible(user))
 1225                    {
 1226                        return false;
 1227                    }
 1228
 1229                    try
 1230                    {
 1231                        return GetChannelProvider(i).IsEnabledFor(userId);
 1232                    }
 1233                    catch
 1234                    {
 1235                        return false;
 1236                    }
 1237                }).ToList();
 238            }
 239
 1240            var all = channels;
 1241            var totalCount = all.Count;
 242
 1243            int startIndex = query.StartIndex ?? 0;
 1244            int count = (query.Limit ?? 0) > 0 ? Math.Min(query.Limit.Value, totalCount - startIndex) : totalCount - sta
 1245            all = all.GetRange(query.StartIndex ?? 0, count);
 246
 1247            if (query.RefreshLatestChannelItems)
 248            {
 0249                foreach (var item in all)
 250                {
 0251                    await RefreshLatestChannelItems(GetChannelProvider(item), CancellationToken.None).ConfigureAwait(fal
 252                }
 253            }
 254
 1255            return new QueryResult<Channel>(
 1256                query.StartIndex,
 1257                totalCount,
 1258                all);
 1259        }
 260
 261        /// <inheritdoc />
 262        public async Task<QueryResult<BaseItemDto>> GetChannelsAsync(ChannelQuery query)
 263        {
 0264            var user = query.UserId.IsEmpty()
 0265                ? null
 0266                : _userManager.GetUserById(query.UserId);
 267
 0268            var internalResult = await GetChannelsInternalAsync(query).ConfigureAwait(false);
 269
 0270            var dtoOptions = new DtoOptions();
 271
 272            // TODO Fix The co-variant conversion (internalResult.Items) between Folder[] and BaseItem[], this can gener
 0273            var returnItems = _dtoService.GetBaseItemDtos(internalResult.Items, dtoOptions, user);
 274
 0275            var result = new QueryResult<BaseItemDto>(
 0276                query.StartIndex,
 0277                internalResult.TotalRecordCount,
 0278                returnItems);
 279
 0280            return result;
 0281        }
 282
 283        /// <summary>
 284        /// Refreshes the associated channels.
 285        /// </summary>
 286        /// <param name="progress">The progress.</param>
 287        /// <param name="cancellationToken">A cancellation token that can be used to cancel the operation.</param>
 288        /// <returns>The completed task.</returns>
 289        public async Task RefreshChannels(IProgress<double> progress, CancellationToken cancellationToken)
 290        {
 0291            var allChannelsList = GetAllChannels().ToList();
 292
 0293            var numComplete = 0;
 294
 0295            foreach (var channelInfo in allChannelsList)
 296            {
 0297                cancellationToken.ThrowIfCancellationRequested();
 298
 299                try
 300                {
 0301                    await GetChannel(channelInfo, cancellationToken).ConfigureAwait(false);
 0302                }
 0303                catch (OperationCanceledException)
 304                {
 0305                    throw;
 306                }
 0307                catch (Exception ex)
 308                {
 0309                    _logger.LogError(ex, "Error getting channel information for {0}", channelInfo.Name);
 0310                }
 311
 0312                numComplete++;
 0313                double percent = (double)numComplete / allChannelsList.Count;
 0314                progress.Report(100 * percent);
 0315            }
 316
 0317            progress.Report(100);
 0318        }
 319
 320        private async IAsyncEnumerable<Channel> GetAllChannelEntitiesAsync()
 321        {
 2322            foreach (IChannel channel in GetAllChannels())
 323            {
 0324                yield return GetChannel(GetInternalChannelId(channel.Name)) ?? await GetChannel(channel, CancellationTok
 325            }
 1326        }
 327
 328        private MediaSourceInfo[] GetSavedMediaSources(BaseItem item)
 329        {
 0330            var path = Path.Combine(item.GetInternalMetadataPath(), "channelmediasourceinfos.json");
 331
 332            try
 333            {
 0334                var bytes = File.ReadAllBytes(path);
 0335                return JsonSerializer.Deserialize<MediaSourceInfo[]>(bytes, _jsonOptions)
 0336                    ?? Array.Empty<MediaSourceInfo>();
 337            }
 0338            catch
 339            {
 0340                return Array.Empty<MediaSourceInfo>();
 341            }
 0342        }
 343
 344        private async Task SaveMediaSources(BaseItem item, List<MediaSourceInfo> mediaSources)
 345        {
 0346            var path = Path.Combine(item.GetInternalMetadataPath(), "channelmediasourceinfos.json");
 347
 0348            if (mediaSources is null || mediaSources.Count == 0)
 349            {
 350                try
 351                {
 0352                    _fileSystem.DeleteFile(path);
 0353                }
 0354                catch
 355                {
 0356                }
 357
 0358                return;
 359            }
 360
 0361            Directory.CreateDirectory(Path.GetDirectoryName(path));
 362
 0363            FileStream createStream = AsyncFile.Create(path);
 0364            await using (createStream.ConfigureAwait(false))
 365            {
 0366                await JsonSerializer.SerializeAsync(createStream, mediaSources, _jsonOptions).ConfigureAwait(false);
 367            }
 0368        }
 369
 370        /// <inheritdoc />
 371        public IEnumerable<MediaSourceInfo> GetStaticMediaSources(BaseItem item, CancellationToken cancellationToken)
 372        {
 0373            IEnumerable<MediaSourceInfo> results = GetSavedMediaSources(item);
 374
 0375            return results
 0376                .Select(i => NormalizeMediaSource(item, i))
 0377                .ToList();
 378        }
 379
 380        /// <summary>
 381        /// Gets the dynamic media sources based on the provided item.
 382        /// </summary>
 383        /// <param name="item">The item.</param>
 384        /// <param name="cancellationToken">A cancellation token that can be used to cancel the operation.</param>
 385        /// <returns>The task representing the operation to get the media sources.</returns>
 386        public async Task<IEnumerable<MediaSourceInfo>> GetDynamicMediaSources(BaseItem item, CancellationToken cancella
 387        {
 0388            var channel = GetChannel(item.ChannelId);
 0389            var channelPlugin = GetChannelProvider(channel);
 390
 391            IEnumerable<MediaSourceInfo> results;
 392
 0393            if (channelPlugin is IRequiresMediaInfoCallback requiresCallback)
 394            {
 0395                results = await GetChannelItemMediaSourcesInternal(requiresCallback, item.ExternalId, cancellationToken)
 0396                    .ConfigureAwait(false);
 397            }
 398            else
 399            {
 0400                results = Enumerable.Empty<MediaSourceInfo>();
 401            }
 402
 0403            return results
 0404                .Select(i => NormalizeMediaSource(item, i))
 0405                .ToList();
 0406        }
 407
 408        private async Task<IEnumerable<MediaSourceInfo>> GetChannelItemMediaSourcesInternal(IRequiresMediaInfoCallback c
 409        {
 0410            if (_memoryCache.TryGetValue(id, out List<MediaSourceInfo> cachedInfo))
 411            {
 0412                return cachedInfo;
 413            }
 414
 0415            var mediaInfo = await channel.GetChannelItemMediaInfo(id, cancellationToken)
 0416                   .ConfigureAwait(false);
 0417            var list = mediaInfo.ToList();
 0418            _memoryCache.Set(id, list, DateTimeOffset.UtcNow.AddMinutes(5));
 419
 0420            return list;
 0421        }
 422
 423        private static MediaSourceInfo NormalizeMediaSource(BaseItem item, MediaSourceInfo info)
 424        {
 0425            info.RunTimeTicks ??= item.RunTimeTicks;
 426
 0427            return info;
 428        }
 429
 430        private async Task<Channel> GetChannel(IChannel channelInfo, CancellationToken cancellationToken)
 431        {
 0432            var parentFolderId = Guid.Empty;
 433
 0434            var id = GetInternalChannelId(channelInfo.Name);
 435
 0436            var path = Channel.GetInternalMetadataPath(_config.ApplicationPaths.InternalMetadataPath, id);
 437
 0438            var isNew = false;
 0439            var forceUpdate = false;
 440
 0441            var item = _libraryManager.GetItemById(id) as Channel;
 442
 0443            if (item is null)
 444            {
 0445                var info = Directory.CreateDirectory(path);
 0446                item = new Channel
 0447                {
 0448                    Name = channelInfo.Name,
 0449                    Id = id,
 0450                    DateCreated = info.CreationTimeUtc,
 0451                    DateModified = info.LastWriteTimeUtc
 0452                };
 453
 0454                isNew = true;
 455            }
 456
 0457            if (!string.Equals(item.Path, path, StringComparison.OrdinalIgnoreCase))
 458            {
 0459                isNew = true;
 460            }
 461
 0462            item.Path = path;
 463
 0464            if (!item.ChannelId.Equals(id))
 465            {
 0466                forceUpdate = true;
 467            }
 468
 0469            item.ChannelId = id;
 470
 0471            if (!item.ParentId.Equals(parentFolderId))
 472            {
 0473                forceUpdate = true;
 474            }
 475
 0476            item.ParentId = parentFolderId;
 477
 0478            item.OfficialRating = GetOfficialRating(channelInfo.ParentalRating);
 0479            item.Overview = channelInfo.Description;
 480
 0481            if (string.IsNullOrWhiteSpace(item.Name))
 482            {
 0483                item.Name = channelInfo.Name;
 484            }
 485
 0486            if (isNew)
 487            {
 0488                item.OnMetadataChanged();
 0489                _libraryManager.CreateItem(item, null);
 490            }
 491
 0492            await item.RefreshMetadata(
 0493                new MetadataRefreshOptions(new DirectoryService(_fileSystem))
 0494                {
 0495                    ForceSave = !isNew && forceUpdate
 0496                },
 0497                cancellationToken).ConfigureAwait(false);
 498
 0499            return item;
 0500        }
 501
 502        private static string GetOfficialRating(ChannelParentalRating rating)
 503        {
 0504            return rating switch
 0505            {
 0506                ChannelParentalRating.Adult => "XXX",
 0507                ChannelParentalRating.UsR => "R",
 0508                ChannelParentalRating.UsPG13 => "PG-13",
 0509                ChannelParentalRating.UsPG => "PG",
 0510                _ => null
 0511            };
 512        }
 513
 514        /// <summary>
 515        /// Gets a channel with the provided Guid.
 516        /// </summary>
 517        /// <param name="id">The Guid.</param>
 518        /// <returns>The corresponding channel.</returns>
 519        public Channel GetChannel(Guid id)
 520        {
 0521            return _libraryManager.GetItemById(id) as Channel;
 522        }
 523
 524        /// <inheritdoc />
 525        public Channel GetChannel(string id)
 526        {
 0527            return _libraryManager.GetItemById(id) as Channel;
 528        }
 529
 530        /// <inheritdoc />
 531        public ChannelFeatures[] GetAllChannelFeatures()
 532        {
 0533            return _libraryManager.GetItemIds(
 0534                new InternalItemsQuery
 0535                {
 0536                    IncludeItemTypes = new[] { BaseItemKind.Channel },
 0537                    OrderBy = new[] { (ItemSortBy.SortName, SortOrder.Ascending) }
 0538                }).Select(i => GetChannelFeatures(i)).ToArray();
 539        }
 540
 541        /// <inheritdoc />
 542        public ChannelFeatures GetChannelFeatures(Guid? id)
 543        {
 0544            if (!id.HasValue)
 545            {
 0546                throw new ArgumentNullException(nameof(id));
 547            }
 548
 0549            var channel = GetChannel(id.Value);
 0550            var channelProvider = GetChannelProvider(channel);
 551
 0552            return GetChannelFeaturesDto(channel, channelProvider, channelProvider.GetChannelFeatures());
 553        }
 554
 555        /// <summary>
 556        /// Gets the provided channel's supported features.
 557        /// </summary>
 558        /// <param name="channel">The channel.</param>
 559        /// <param name="provider">The provider.</param>
 560        /// <param name="features">The features.</param>
 561        /// <returns>The supported features.</returns>
 562        public ChannelFeatures GetChannelFeaturesDto(
 563            Channel channel,
 564            IChannel provider,
 565            InternalChannelFeatures features)
 566        {
 0567            var supportsLatest = provider is ISupportsLatestMedia;
 568
 0569            return new ChannelFeatures(channel.Name, channel.Id)
 0570            {
 0571                CanFilter = !features.MaxPageSize.HasValue,
 0572                ContentTypes = features.ContentTypes.ToArray(),
 0573                DefaultSortFields = features.DefaultSortFields.ToArray(),
 0574                MaxPageSize = features.MaxPageSize,
 0575                MediaTypes = features.MediaTypes.ToArray(),
 0576                SupportsSortOrderToggle = features.SupportsSortOrderToggle,
 0577                SupportsLatestMedia = supportsLatest,
 0578                SupportsContentDownloading = features.SupportsContentDownloading,
 0579                AutoRefreshLevels = features.AutoRefreshLevels
 0580            };
 581        }
 582
 583        private Guid GetInternalChannelId(string name)
 584        {
 0585            ArgumentException.ThrowIfNullOrEmpty(name);
 586
 0587            return _libraryManager.GetNewItemId("Channel " + name, typeof(Channel));
 588        }
 589
 590        /// <inheritdoc />
 591        public async Task<QueryResult<BaseItemDto>> GetLatestChannelItems(InternalItemsQuery query, CancellationToken ca
 592        {
 0593            var internalResult = await GetLatestChannelItemsInternal(query, cancellationToken).ConfigureAwait(false);
 594
 0595            var items = internalResult.Items;
 0596            var totalRecordCount = internalResult.TotalRecordCount;
 597
 0598            var returnItems = _dtoService.GetBaseItemDtos(items, query.DtoOptions, query.User);
 599
 0600            var result = new QueryResult<BaseItemDto>(
 0601                query.StartIndex,
 0602                totalRecordCount,
 0603                returnItems);
 604
 0605            return result;
 0606        }
 607
 608        /// <inheritdoc />
 609        public async Task<QueryResult<BaseItem>> GetLatestChannelItemsInternal(InternalItemsQuery query, CancellationTok
 610        {
 0611            var channels = GetAllChannels().Where(i => i is ISupportsLatestMedia).ToArray();
 612
 0613            if (query.ChannelIds.Count > 0)
 614            {
 615                // Avoid implicitly captured closure
 0616                var ids = query.ChannelIds;
 0617                channels = channels
 0618                    .Where(i => ids.Contains(GetInternalChannelId(i.Name)))
 0619                    .ToArray();
 620            }
 621
 0622            if (channels.Length == 0)
 623            {
 0624                return new QueryResult<BaseItem>();
 625            }
 626
 0627            foreach (var channel in channels)
 628            {
 0629                await RefreshLatestChannelItems(channel, cancellationToken).ConfigureAwait(false);
 630            }
 631
 0632            query.IsFolder = false;
 633
 634            // hack for trailers, figure out a better way later
 0635            var sortByPremiereDate = channels.Length == 1 && channels[0].GetType().Name.Contains("Trailer", StringCompar
 636
 0637            if (sortByPremiereDate)
 638            {
 0639                query.OrderBy = new[]
 0640                {
 0641                    (ItemSortBy.PremiereDate, SortOrder.Descending),
 0642                    (ItemSortBy.ProductionYear, SortOrder.Descending),
 0643                    (ItemSortBy.DateCreated, SortOrder.Descending)
 0644                };
 645            }
 646            else
 647            {
 0648                query.OrderBy = new[]
 0649                {
 0650                    (ItemSortBy.DateCreated, SortOrder.Descending)
 0651                };
 652            }
 653
 0654            return _libraryManager.GetItemsResult(query);
 0655        }
 656
 657        private async Task RefreshLatestChannelItems(IChannel channel, CancellationToken cancellationToken)
 658        {
 0659            var internalChannel = await GetChannel(channel, cancellationToken).ConfigureAwait(false);
 660
 0661            var query = new InternalItemsQuery
 0662            {
 0663                Parent = internalChannel,
 0664                EnableTotalRecordCount = false,
 0665                ChannelIds = new Guid[] { internalChannel.Id }
 0666            };
 667
 0668            var result = await GetChannelItemsInternal(query, new Progress<double>(), cancellationToken).ConfigureAwait(
 669
 0670            foreach (var item in result.Items)
 671            {
 0672                if (item is Folder folder)
 673                {
 0674                    await GetChannelItemsInternal(
 0675                        new InternalItemsQuery
 0676                        {
 0677                            Parent = folder,
 0678                            EnableTotalRecordCount = false,
 0679                            ChannelIds = new Guid[] { internalChannel.Id }
 0680                        },
 0681                        new Progress<double>(),
 0682                        cancellationToken).ConfigureAwait(false);
 683                }
 684            }
 0685        }
 686
 687        /// <inheritdoc />
 688        public async Task<QueryResult<BaseItem>> GetChannelItemsInternal(InternalItemsQuery query, IProgress<double> pro
 689        {
 690            // Get the internal channel entity
 0691            var channel = GetChannel(query.ChannelIds[0]);
 692
 693            // Find the corresponding channel provider plugin
 0694            var channelProvider = GetChannelProvider(channel);
 695
 0696            var parentItem = query.ParentId.IsEmpty()
 0697                ? channel
 0698                : _libraryManager.GetItemById(query.ParentId);
 699
 0700            var itemsResult = await GetChannelItems(
 0701                channelProvider,
 0702                query.User,
 0703                parentItem is Channel ? null : parentItem.ExternalId,
 0704                null,
 0705                false,
 0706                cancellationToken)
 0707                .ConfigureAwait(false);
 708
 0709            if (query.ParentId.IsEmpty())
 710            {
 0711                query.Parent = channel;
 712            }
 713
 0714            query.ChannelIds = Array.Empty<Guid>();
 715
 716            // Not yet sure why this is causing a problem
 0717            query.GroupByPresentationUniqueKey = false;
 718
 719            // null if came from cache
 0720            if (itemsResult is not null)
 721            {
 0722                var items = itemsResult.Items;
 0723                var itemsLen = items.Count;
 0724                var internalItems = new Guid[itemsLen];
 0725                for (int i = 0; i < itemsLen; i++)
 726                {
 0727                    internalItems[i] = (await GetChannelItemEntityAsync(
 0728                        items[i],
 0729                        channelProvider,
 0730                        channel.Id,
 0731                        parentItem,
 0732                        cancellationToken).ConfigureAwait(false)).Id;
 733                }
 734
 0735                var existingIds = _libraryManager.GetItemIds(query);
 0736                var deadIds = existingIds.Except(internalItems)
 0737                    .ToArray();
 738
 0739                foreach (var deadId in deadIds)
 740                {
 0741                    var deadItem = _libraryManager.GetItemById(deadId);
 0742                    if (deadItem is not null)
 743                    {
 0744                        _libraryManager.DeleteItem(
 0745                            deadItem,
 0746                            new DeleteOptions
 0747                            {
 0748                                DeleteFileLocation = false,
 0749                                DeleteFromExternalProvider = false
 0750                            },
 0751                            parentItem,
 0752                            false);
 753                    }
 754                }
 0755            }
 756
 0757            return _libraryManager.GetItemsResult(query);
 0758        }
 759
 760        /// <inheritdoc />
 761        public async Task<QueryResult<BaseItemDto>> GetChannelItems(InternalItemsQuery query, CancellationToken cancella
 762        {
 0763            var internalResult = await GetChannelItemsInternal(query, new Progress<double>(), cancellationToken).Configu
 764
 0765            var returnItems = _dtoService.GetBaseItemDtos(internalResult.Items, query.DtoOptions, query.User);
 766
 0767            var result = new QueryResult<BaseItemDto>(
 0768                query.StartIndex,
 0769                internalResult.TotalRecordCount,
 0770                returnItems);
 771
 0772            return result;
 0773        }
 774
 775        private async Task<ChannelItemResult> GetChannelItems(
 776            IChannel channel,
 777            User user,
 778            string externalFolderId,
 779            ChannelItemSortField? sortField,
 780            bool sortDescending,
 781            CancellationToken cancellationToken)
 782        {
 0783            var userId = user?.Id.ToString("N", CultureInfo.InvariantCulture);
 784
 0785            var cacheLength = CacheLength;
 0786            var cachePath = GetChannelDataCachePath(channel, userId, externalFolderId, sortField, sortDescending);
 787
 788            try
 789            {
 0790                if (_fileSystem.GetLastWriteTimeUtc(cachePath).Add(cacheLength) > DateTime.UtcNow)
 791                {
 0792                    var jsonStream = AsyncFile.OpenRead(cachePath);
 0793                    await using (jsonStream.ConfigureAwait(false))
 794                    {
 0795                        var cachedResult = await JsonSerializer
 0796                            .DeserializeAsync<ChannelItemResult>(jsonStream, _jsonOptions, cancellationToken)
 0797                            .ConfigureAwait(false);
 0798                        if (cachedResult is not null)
 799                        {
 0800                            return null;
 801                        }
 802                    }
 803                }
 0804            }
 0805            catch (FileNotFoundException)
 806            {
 0807            }
 0808            catch (IOException)
 809            {
 0810            }
 811
 0812            using (await _resourcePool.LockAsync(cancellationToken).ConfigureAwait(false))
 813            {
 814                try
 815                {
 0816                    if (_fileSystem.GetLastWriteTimeUtc(cachePath).Add(cacheLength) > DateTime.UtcNow)
 817                    {
 0818                        var jsonStream = AsyncFile.OpenRead(cachePath);
 0819                        await using (jsonStream.ConfigureAwait(false))
 820                        {
 0821                            var cachedResult = await JsonSerializer
 0822                                .DeserializeAsync<ChannelItemResult>(jsonStream, _jsonOptions, cancellationToken)
 0823                                .ConfigureAwait(false);
 0824                            if (cachedResult is not null)
 825                            {
 0826                                return null;
 827                            }
 828                        }
 829                    }
 0830                }
 0831                catch (FileNotFoundException)
 832                {
 0833                }
 0834                catch (IOException)
 835                {
 0836                }
 837
 0838                var query = new InternalChannelItemQuery
 0839                {
 0840                    UserId = user?.Id ?? Guid.Empty,
 0841                    SortBy = sortField,
 0842                    SortDescending = sortDescending,
 0843                    FolderId = externalFolderId
 0844                };
 845
 0846                query.FolderId = externalFolderId;
 847
 0848                var result = await channel.GetChannelItems(query, cancellationToken).ConfigureAwait(false);
 849
 0850                if (result is null)
 851                {
 0852                    throw new InvalidOperationException("Channel returned a null result from GetChannelItems");
 853                }
 854
 0855                await CacheResponse(result, cachePath).ConfigureAwait(false);
 856
 0857                return result;
 858            }
 0859        }
 860
 861        private async Task CacheResponse(ChannelItemResult result, string path)
 862        {
 863            try
 864            {
 0865                Directory.CreateDirectory(Path.GetDirectoryName(path));
 866
 0867                var createStream = AsyncFile.Create(path);
 0868                await using (createStream.ConfigureAwait(false))
 869                {
 0870                    await JsonSerializer.SerializeAsync(createStream, result, _jsonOptions).ConfigureAwait(false);
 871                }
 0872            }
 0873            catch (Exception ex)
 874            {
 0875                _logger.LogError(ex, "Error writing to channel cache file: {Path}", path);
 0876            }
 0877        }
 878
 879        private string GetChannelDataCachePath(
 880            IChannel channel,
 881            string userId,
 882            string externalFolderId,
 883            ChannelItemSortField? sortField,
 884            bool sortDescending)
 885        {
 0886            var channelId = GetInternalChannelId(channel.Name).ToString("N", CultureInfo.InvariantCulture);
 887
 0888            var userCacheKey = string.Empty;
 889
 0890            if (channel is IHasCacheKey hasCacheKey)
 891            {
 0892                userCacheKey = hasCacheKey.GetCacheKey(userId) ?? string.Empty;
 893            }
 894
 0895            var filename = string.IsNullOrEmpty(externalFolderId) ? "root" : externalFolderId.GetMD5().ToString("N", Cul
 0896            filename += userCacheKey;
 897
 0898            var version = ((channel.DataVersion ?? string.Empty) + "2").GetMD5().ToString("N", CultureInfo.InvariantCult
 899
 0900            if (sortField.HasValue)
 901            {
 0902                filename += "-sortField-" + sortField.Value;
 903            }
 904
 0905            if (sortDescending)
 906            {
 0907                filename += "-sortDescending";
 908            }
 909
 0910            filename = filename.GetMD5().ToString("N", CultureInfo.InvariantCulture);
 911
 0912            return Path.Combine(
 0913                _config.ApplicationPaths.CachePath,
 0914                "channels",
 0915                channelId,
 0916                version,
 0917                filename + ".json");
 918        }
 919
 920        private static string GetIdToHash(string externalId, string channelName)
 921        {
 922            // Increment this as needed to force new downloads
 923            // Incorporate Name because it's being used to convert channel entity to provider
 0924            return externalId + (channelName ?? string.Empty) + "16";
 925        }
 926
 927        private T GetItemById<T>(string idString, string channelName, out bool isNew)
 928            where T : BaseItem, new()
 929        {
 0930            var id = _libraryManager.GetNewItemId(GetIdToHash(idString, channelName), typeof(T));
 931
 0932            T item = null;
 933
 934            try
 935            {
 0936                item = _libraryManager.GetItemById(id) as T;
 0937            }
 0938            catch (Exception ex)
 939            {
 0940                _logger.LogError(ex, "Error retrieving channel item from database");
 0941            }
 942
 0943            if (item is null)
 944            {
 0945                item = new T();
 0946                isNew = true;
 947            }
 948            else
 949            {
 0950                isNew = false;
 951            }
 952
 0953            item.Id = id;
 0954            return item;
 955        }
 956
 957        private async Task<BaseItem> GetChannelItemEntityAsync(ChannelItemInfo info, IChannel channelProvider, Guid inte
 958        {
 0959            var parentFolderId = parentFolder.Id;
 960
 961            BaseItem item;
 962            bool isNew;
 0963            bool forceUpdate = false;
 964
 0965            if (info.Type == ChannelItemType.Folder)
 966            {
 0967                item = info.FolderType switch
 0968                {
 0969                    ChannelFolderType.MusicAlbum => GetItemById<MusicAlbum>(info.Id, channelProvider.Name, out isNew),
 0970                    ChannelFolderType.MusicArtist => GetItemById<MusicArtist>(info.Id, channelProvider.Name, out isNew),
 0971                    ChannelFolderType.PhotoAlbum => GetItemById<PhotoAlbum>(info.Id, channelProvider.Name, out isNew),
 0972                    ChannelFolderType.Series => GetItemById<Series>(info.Id, channelProvider.Name, out isNew),
 0973                    ChannelFolderType.Season => GetItemById<Season>(info.Id, channelProvider.Name, out isNew),
 0974                    _ => GetItemById<Folder>(info.Id, channelProvider.Name, out isNew)
 0975                };
 976            }
 0977            else if (info.MediaType == ChannelMediaType.Audio)
 978            {
 0979                item = info.ContentType == ChannelMediaContentType.Podcast
 0980                    ? GetItemById<AudioBook>(info.Id, channelProvider.Name, out isNew)
 0981                    : GetItemById<Audio>(info.Id, channelProvider.Name, out isNew);
 982            }
 983            else
 984            {
 0985                item = info.ContentType switch
 0986                {
 0987                    ChannelMediaContentType.Episode => GetItemById<Episode>(info.Id, channelProvider.Name, out isNew),
 0988                    ChannelMediaContentType.Movie => GetItemById<Movie>(info.Id, channelProvider.Name, out isNew),
 0989                    var x when x == ChannelMediaContentType.Trailer || info.ExtraType == ExtraType.Trailer
 0990                    => GetItemById<Trailer>(info.Id, channelProvider.Name, out isNew),
 0991                    _ => GetItemById<Video>(info.Id, channelProvider.Name, out isNew)
 0992                };
 993            }
 994
 0995            var enableMediaProbe = channelProvider is ISupportsMediaProbe;
 996
 0997            if (info.IsLiveStream)
 998            {
 0999                item.RunTimeTicks = null;
 1000            }
 01001            else if (isNew || !enableMediaProbe)
 1002            {
 01003                item.RunTimeTicks = info.RunTimeTicks;
 1004            }
 1005
 01006            if (isNew)
 1007            {
 01008                item.Name = info.Name;
 01009                item.Genres = info.Genres.ToArray();
 01010                item.Studios = info.Studios.ToArray();
 01011                item.CommunityRating = info.CommunityRating;
 01012                item.Overview = info.Overview;
 01013                item.IndexNumber = info.IndexNumber;
 01014                item.ParentIndexNumber = info.ParentIndexNumber;
 01015                item.PremiereDate = info.PremiereDate;
 01016                item.ProductionYear = info.ProductionYear;
 01017                item.ProviderIds = info.ProviderIds;
 01018                item.OfficialRating = info.OfficialRating;
 01019                item.DateCreated = info.DateCreated ?? DateTime.UtcNow;
 01020                item.Tags = info.Tags.ToArray();
 01021                item.OriginalTitle = info.OriginalTitle;
 1022            }
 01023            else if (info.Type == ChannelItemType.Folder && info.FolderType == ChannelFolderType.Container)
 1024            {
 1025                // At least update names of container folders
 01026                if (item.Name != info.Name)
 1027                {
 01028                    item.Name = info.Name;
 01029                    forceUpdate = true;
 1030                }
 1031            }
 1032
 01033            if (item is IHasArtist hasArtists)
 1034            {
 01035                hasArtists.Artists = info.Artists.ToArray();
 1036            }
 1037
 01038            if (item is IHasAlbumArtist hasAlbumArtists)
 1039            {
 01040                hasAlbumArtists.AlbumArtists = info.AlbumArtists.ToArray();
 1041            }
 1042
 01043            if (item is Trailer trailer)
 1044            {
 01045                if (!info.TrailerTypes.SequenceEqual(trailer.TrailerTypes))
 1046                {
 01047                    _logger.LogDebug("Forcing update due to TrailerTypes {0}", item.Name);
 01048                    forceUpdate = true;
 1049                }
 1050
 01051                trailer.TrailerTypes = info.TrailerTypes.ToArray();
 1052            }
 1053
 01054            if (info.DateModified > item.DateModified)
 1055            {
 01056                item.DateModified = info.DateModified;
 01057                _logger.LogDebug("Forcing update due to DateModified {0}", item.Name);
 01058                forceUpdate = true;
 1059            }
 1060
 01061            if (!internalChannelId.Equals(item.ChannelId))
 1062            {
 01063                forceUpdate = true;
 01064                _logger.LogDebug("Forcing update due to ChannelId {0}", item.Name);
 1065            }
 1066
 01067            item.ChannelId = internalChannelId;
 1068
 01069            if (!item.ParentId.Equals(parentFolderId))
 1070            {
 01071                forceUpdate = true;
 01072                _logger.LogDebug("Forcing update due to parent folder Id {0}", item.Name);
 1073            }
 1074
 01075            item.ParentId = parentFolderId;
 1076
 01077            if (item is IHasSeries hasSeries)
 1078            {
 01079                if (!string.Equals(hasSeries.SeriesName, info.SeriesName, StringComparison.OrdinalIgnoreCase))
 1080                {
 01081                    forceUpdate = true;
 01082                    _logger.LogDebug("Forcing update due to SeriesName {0}", item.Name);
 1083                }
 1084
 01085                hasSeries.SeriesName = info.SeriesName;
 1086            }
 1087
 01088            if (!string.Equals(item.ExternalId, info.Id, StringComparison.OrdinalIgnoreCase))
 1089            {
 01090                forceUpdate = true;
 01091                _logger.LogDebug("Forcing update due to ExternalId {0}", item.Name);
 1092            }
 1093
 01094            item.ExternalId = info.Id;
 1095
 01096            if (item is Audio channelAudioItem)
 1097            {
 01098                channelAudioItem.ExtraType = info.ExtraType;
 1099
 01100                var mediaSource = info.MediaSources.FirstOrDefault();
 01101                item.Path = mediaSource?.Path;
 1102            }
 1103
 01104            if (item is Video channelVideoItem)
 1105            {
 01106                channelVideoItem.ExtraType = info.ExtraType;
 1107
 01108                var mediaSource = info.MediaSources.FirstOrDefault();
 01109                item.Path = mediaSource?.Path;
 1110            }
 1111
 01112            if (!string.IsNullOrEmpty(info.ImageUrl) && !item.HasImage(ImageType.Primary))
 1113            {
 01114                item.SetImagePath(ImageType.Primary, info.ImageUrl);
 01115                _logger.LogDebug("Forcing update due to ImageUrl {0}", item.Name);
 01116                forceUpdate = true;
 1117            }
 1118
 01119            if (!info.IsLiveStream)
 1120            {
 01121                if (item.Tags.Contains("livestream", StringComparison.OrdinalIgnoreCase))
 1122                {
 01123                    item.Tags = item.Tags.Except(new[] { "livestream" }, StringComparer.OrdinalIgnoreCase).ToArray();
 01124                    _logger.LogDebug("Forcing update due to Tags {0}", item.Name);
 01125                    forceUpdate = true;
 1126                }
 1127            }
 1128            else
 1129            {
 01130                if (!item.Tags.Contains("livestream", StringComparison.OrdinalIgnoreCase))
 1131                {
 01132                    item.Tags = [..item.Tags, "livestream"];
 01133                    _logger.LogDebug("Forcing update due to Tags {0}", item.Name);
 01134                    forceUpdate = true;
 1135                }
 1136            }
 1137
 01138            item.OnMetadataChanged();
 1139
 01140            if (isNew)
 1141            {
 01142                _libraryManager.CreateItem(item, parentFolder);
 1143
 01144                if (info.People is not null && info.People.Count > 0)
 1145                {
 01146                    await _libraryManager.UpdatePeopleAsync(item, info.People, cancellationToken).ConfigureAwait(false);
 1147                }
 1148            }
 01149            else if (forceUpdate)
 1150            {
 01151                await item.UpdateToRepositoryAsync(ItemUpdateType.None, cancellationToken).ConfigureAwait(false);
 1152            }
 1153
 01154            if ((isNew || forceUpdate) && info.Type == ChannelItemType.Media)
 1155            {
 01156                if (enableMediaProbe && !info.IsLiveStream && item.HasPathProtocol)
 1157                {
 01158                    await SaveMediaSources(item, new List<MediaSourceInfo>()).ConfigureAwait(false);
 1159                }
 1160                else
 1161                {
 01162                    await SaveMediaSources(item, info.MediaSources).ConfigureAwait(false);
 1163                }
 1164            }
 1165
 01166            if (isNew || forceUpdate || item.DateLastRefreshed == DateTime.MinValue)
 1167            {
 01168                _providerManager.QueueRefresh(item.Id, new MetadataRefreshOptions(new DirectoryService(_fileSystem)), Re
 1169            }
 1170
 01171            return item;
 01172        }
 1173
 1174        internal IChannel GetChannelProvider(Channel channel)
 1175        {
 01176            ArgumentNullException.ThrowIfNull(channel);
 1177
 01178            var result = GetAllChannels()
 01179                .FirstOrDefault(i => GetInternalChannelId(i.Name).Equals(channel.ChannelId) || string.Equals(i.Name, cha
 1180
 01181            if (result is null)
 1182            {
 01183                throw new ResourceNotFoundException("No channel provider found for channel " + channel.Name);
 1184            }
 1185
 01186            return result;
 1187        }
 1188
 1189        /// <inheritdoc />
 1190        public void Dispose()
 1191        {
 211192            Dispose(true);
 211193            GC.SuppressFinalize(this);
 211194        }
 1195
 1196        /// <summary>
 1197        /// Releases unmanaged and optionally managed resources.
 1198        /// </summary>
 1199        /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release
 1200        protected virtual void Dispose(bool disposing)
 1201        {
 211202            if (_disposed)
 1203            {
 01204                return;
 1205            }
 1206
 211207            if (disposing)
 1208            {
 211209                _resourcePool?.Dispose();
 1210            }
 1211
 211212            _disposed = true;
 211213        }
 1214    }
 1215}
Generated by: ReportGenerator 5.5.7.0
5/6/2026 - 12:15:25 AM
GitHub | reportgenerator.io

Methods/Properties

.ctor(MediaBrowser.Controller.Library.IUserManager,MediaBrowser.Controller.Dto.IDtoService,MediaBrowser.Controller.Library.ILibraryManager,Microsoft.Extensions.Logging.ILogger`1<Jellyfin.LiveTv.Channels.ChannelManager>,MediaBrowser.Controller.Configuration.IServerConfigurationManager,MediaBrowser.Model.IO.IFileSystem,MediaBrowser.Controller.Library.IUserDataManager,MediaBrowser.Controller.Providers.IProviderManager,Microsoft.Extensions.Caching.Memory.IMemoryCache,System.Collections.Generic.IEnumerable`1<MediaBrowser.Controller.Channels.IChannel>)
get_CacheLength()
EnableMediaSourceDisplay(MediaBrowser.Controller.Entities.BaseItem)
CanDelete(MediaBrowser.Controller.Entities.BaseItem)
DeleteItem(MediaBrowser.Controller.Entities.BaseItem)
GetAllChannels()
GetInstalledChannelIds()
GetChannelsInternalAsync()
GetChannelsAsync()
RefreshChannels()
GetAllChannelEntitiesAsync()
GetSavedMediaSources(MediaBrowser.Controller.Entities.BaseItem)
SaveMediaSources()
GetStaticMediaSources(MediaBrowser.Controller.Entities.BaseItem,System.Threading.CancellationToken)
GetDynamicMediaSources()
GetChannelItemMediaSourcesInternal()
NormalizeMediaSource(MediaBrowser.Controller.Entities.BaseItem,MediaBrowser.Model.Dto.MediaSourceInfo)
GetChannel()
GetOfficialRating(MediaBrowser.Controller.Channels.ChannelParentalRating)
GetChannel(System.Guid)
GetChannel(System.String)
GetAllChannelFeatures()
GetChannelFeatures(System.Nullable`1<System.Guid>)
GetChannelFeaturesDto(MediaBrowser.Controller.Channels.Channel,MediaBrowser.Controller.Channels.IChannel,MediaBrowser.Controller.Channels.InternalChannelFeatures)
GetInternalChannelId(System.String)
GetLatestChannelItems()
GetLatestChannelItemsInternal()
RefreshLatestChannelItems()
GetChannelItemsInternal()
GetChannelItems()
GetChannelItems()
CacheResponse()
GetChannelDataCachePath(MediaBrowser.Controller.Channels.IChannel,System.String,System.String,System.Nullable`1<MediaBrowser.Model.Channels.ChannelItemSortField>,System.Boolean)
GetIdToHash(System.String,System.String)
GetItemById(System.String,System.String,System.Boolean&)
GetChannelItemEntityAsync()
GetChannelProvider(MediaBrowser.Controller.Channels.Channel)
Dispose()
Dispose(System.Boolean)