ChannelManager.cs 57 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642
  1. using System.Net;
  2. using System.Text;
  3. using MediaBrowser.Common.Extensions;
  4. using MediaBrowser.Common.IO;
  5. using MediaBrowser.Common.Net;
  6. using MediaBrowser.Controller.Channels;
  7. using MediaBrowser.Controller.Configuration;
  8. using MediaBrowser.Controller.Dto;
  9. using MediaBrowser.Controller.Entities;
  10. using MediaBrowser.Controller.Library;
  11. using MediaBrowser.Controller.Localization;
  12. using MediaBrowser.Controller.Providers;
  13. using MediaBrowser.Controller.Resolvers;
  14. using MediaBrowser.Model.Channels;
  15. using MediaBrowser.Model.Dto;
  16. using MediaBrowser.Model.Entities;
  17. using MediaBrowser.Model.Logging;
  18. using MediaBrowser.Model.MediaInfo;
  19. using MediaBrowser.Model.Net;
  20. using MediaBrowser.Model.Querying;
  21. using MediaBrowser.Model.Serialization;
  22. using System;
  23. using System.Collections.Concurrent;
  24. using System.Collections.Generic;
  25. using System.IO;
  26. using System.Linq;
  27. using System.Threading;
  28. using System.Threading.Tasks;
  29. using MediaBrowser.Server.Implementations.Library;
  30. namespace MediaBrowser.Server.Implementations.Channels
  31. {
  32. public class ChannelManager : IChannelManager, IDisposable
  33. {
  34. private IChannel[] _channels;
  35. private IChannelFactory[] _factories;
  36. private readonly IUserManager _userManager;
  37. private readonly IUserDataManager _userDataManager;
  38. private readonly IDtoService _dtoService;
  39. private readonly ILibraryManager _libraryManager;
  40. private readonly ILogger _logger;
  41. private readonly IServerConfigurationManager _config;
  42. private readonly IFileSystem _fileSystem;
  43. private readonly IJsonSerializer _jsonSerializer;
  44. private readonly IHttpClient _httpClient;
  45. private readonly ILocalizationManager _localization;
  46. private readonly ConcurrentDictionary<Guid, bool> _refreshedItems = new ConcurrentDictionary<Guid, bool>();
  47. private readonly ConcurrentDictionary<string, int> _downloadCounts = new ConcurrentDictionary<string, int>();
  48. private Timer _refreshTimer;
  49. private Timer _clearDownloadCountsTimer;
  50. public ChannelManager(IUserManager userManager, IDtoService dtoService, ILibraryManager libraryManager, ILogger logger, IServerConfigurationManager config, IFileSystem fileSystem, IUserDataManager userDataManager, IJsonSerializer jsonSerializer, ILocalizationManager localization, IHttpClient httpClient)
  51. {
  52. _userManager = userManager;
  53. _dtoService = dtoService;
  54. _libraryManager = libraryManager;
  55. _logger = logger;
  56. _config = config;
  57. _fileSystem = fileSystem;
  58. _userDataManager = userDataManager;
  59. _jsonSerializer = jsonSerializer;
  60. _localization = localization;
  61. _httpClient = httpClient;
  62. _refreshTimer = new Timer(s => _refreshedItems.Clear(), null, TimeSpan.FromHours(3), TimeSpan.FromHours(3));
  63. _clearDownloadCountsTimer = new Timer(s => _downloadCounts.Clear(), null, TimeSpan.FromHours(24), TimeSpan.FromHours(24));
  64. }
  65. private TimeSpan CacheLength
  66. {
  67. get
  68. {
  69. return TimeSpan.FromHours(6);
  70. }
  71. }
  72. public void AddParts(IEnumerable<IChannel> channels, IEnumerable<IChannelFactory> factories)
  73. {
  74. _channels = channels.Where(i => !(i is IFactoryChannel)).ToArray();
  75. _factories = factories.ToArray();
  76. }
  77. public string ChannelDownloadPath
  78. {
  79. get
  80. {
  81. var options = _config.GetChannelsConfiguration();
  82. if (!string.IsNullOrWhiteSpace(options.DownloadPath))
  83. {
  84. return options.DownloadPath;
  85. }
  86. return Path.Combine(_config.ApplicationPaths.ProgramDataPath, "channels");
  87. }
  88. }
  89. private IEnumerable<IChannel> GetAllChannels()
  90. {
  91. return _factories
  92. .SelectMany(i =>
  93. {
  94. try
  95. {
  96. return i.GetChannels().ToList();
  97. }
  98. catch (Exception ex)
  99. {
  100. _logger.ErrorException("Error getting channel list", ex);
  101. return new List<IChannel>();
  102. }
  103. })
  104. .Concat(_channels)
  105. .OrderBy(i => i.Name);
  106. }
  107. public Task<QueryResult<Channel>> GetChannelsInternal(ChannelQuery query, CancellationToken cancellationToken)
  108. {
  109. var user = string.IsNullOrWhiteSpace(query.UserId)
  110. ? null
  111. : _userManager.GetUserById(query.UserId);
  112. var channels = GetAllChannels()
  113. .Select(GetChannelEntity)
  114. .OrderBy(i => i.SortName)
  115. .ToList();
  116. if (query.SupportsLatestItems.HasValue)
  117. {
  118. var val = query.SupportsLatestItems.Value;
  119. channels = channels.Where(i => (GetChannelProvider(i) is ISupportsLatestMedia) == val)
  120. .ToList();
  121. }
  122. if (query.IsFavorite.HasValue)
  123. {
  124. var val = query.IsFavorite.Value;
  125. channels = channels.Where(i => _userDataManager.GetUserData(user.Id, i.GetUserDataKey()).IsFavorite == val)
  126. .ToList();
  127. }
  128. if (user != null)
  129. {
  130. channels = channels.Where(i => GetChannelProvider(i).IsEnabledFor(user.Id.ToString("N")) && i.IsVisible(user))
  131. .ToList();
  132. }
  133. var all = channels;
  134. var totalCount = all.Count;
  135. if (query.StartIndex.HasValue)
  136. {
  137. all = all.Skip(query.StartIndex.Value).ToList();
  138. }
  139. if (query.Limit.HasValue)
  140. {
  141. all = all.Take(query.Limit.Value).ToList();
  142. }
  143. var returnItems = all.ToArray();
  144. var result = new QueryResult<Channel>
  145. {
  146. Items = returnItems,
  147. TotalRecordCount = totalCount
  148. };
  149. return Task.FromResult(result);
  150. }
  151. public async Task<QueryResult<BaseItemDto>> GetChannels(ChannelQuery query, CancellationToken cancellationToken)
  152. {
  153. var user = string.IsNullOrWhiteSpace(query.UserId)
  154. ? null
  155. : _userManager.GetUserById(query.UserId);
  156. var internalResult = await GetChannelsInternal(query, cancellationToken).ConfigureAwait(false);
  157. // Get everything
  158. var fields = Enum.GetNames(typeof(ItemFields))
  159. .Select(i => (ItemFields)Enum.Parse(typeof(ItemFields), i, true))
  160. .ToList();
  161. var returnItems = internalResult.Items.Select(i => _dtoService.GetBaseItemDto(i, fields, user))
  162. .ToArray();
  163. var result = new QueryResult<BaseItemDto>
  164. {
  165. Items = returnItems,
  166. TotalRecordCount = internalResult.TotalRecordCount
  167. };
  168. return result;
  169. }
  170. public async Task RefreshChannels(IProgress<double> progress, CancellationToken cancellationToken)
  171. {
  172. var allChannelsList = GetAllChannels().ToList();
  173. var numComplete = 0;
  174. foreach (var channelInfo in allChannelsList)
  175. {
  176. cancellationToken.ThrowIfCancellationRequested();
  177. try
  178. {
  179. var item = await GetChannel(channelInfo, cancellationToken).ConfigureAwait(false);
  180. _libraryManager.RegisterItem(item);
  181. }
  182. catch (OperationCanceledException)
  183. {
  184. throw;
  185. }
  186. catch (Exception ex)
  187. {
  188. _logger.ErrorException("Error getting channel information for {0}", ex, channelInfo.Name);
  189. }
  190. numComplete++;
  191. double percent = numComplete;
  192. percent /= allChannelsList.Count;
  193. progress.Report(100 * percent);
  194. }
  195. progress.Report(100);
  196. }
  197. private Channel GetChannelEntity(IChannel channel)
  198. {
  199. var item = GetChannel(GetInternalChannelId(channel.Name).ToString("N"));
  200. if (item == null)
  201. {
  202. item = GetChannel(channel, CancellationToken.None).Result;
  203. _libraryManager.RegisterItem(item);
  204. }
  205. return item;
  206. }
  207. public async Task<IEnumerable<MediaSourceInfo>> GetChannelItemMediaSources(string id, bool includeDynamicSources, CancellationToken cancellationToken)
  208. {
  209. var item = (IChannelMediaItem)_libraryManager.GetItemById(id);
  210. var channel = GetChannel(item.ChannelId);
  211. var channelPlugin = GetChannelProvider(channel);
  212. var requiresCallback = channelPlugin as IRequiresMediaInfoCallback;
  213. IEnumerable<ChannelMediaInfo> results;
  214. if (requiresCallback != null && includeDynamicSources)
  215. {
  216. results = await GetChannelItemMediaSourcesInternal(requiresCallback, item.ExternalId, cancellationToken)
  217. .ConfigureAwait(false);
  218. }
  219. else
  220. {
  221. results = item.ChannelMediaSources;
  222. }
  223. var sources = SortMediaInfoResults(results).Select(i => GetMediaSource(item, i))
  224. .ToList();
  225. var cachedVersions = GetCachedChannelItemMediaSources(item);
  226. sources.InsertRange(0, cachedVersions);
  227. return sources.Where(IsValidMediaSource);
  228. }
  229. private readonly ConcurrentDictionary<string, Tuple<DateTime, List<ChannelMediaInfo>>> _channelItemMediaInfo =
  230. new ConcurrentDictionary<string, Tuple<DateTime, List<ChannelMediaInfo>>>();
  231. private async Task<IEnumerable<ChannelMediaInfo>> GetChannelItemMediaSourcesInternal(IRequiresMediaInfoCallback channel, string id, CancellationToken cancellationToken)
  232. {
  233. Tuple<DateTime, List<ChannelMediaInfo>> cachedInfo;
  234. if (_channelItemMediaInfo.TryGetValue(id, out cachedInfo))
  235. {
  236. if ((DateTime.UtcNow - cachedInfo.Item1).TotalMinutes < 5)
  237. {
  238. return cachedInfo.Item2;
  239. }
  240. }
  241. var mediaInfo = await channel.GetChannelItemMediaInfo(id, cancellationToken)
  242. .ConfigureAwait(false);
  243. var list = mediaInfo.ToList();
  244. var item2 = new Tuple<DateTime, List<ChannelMediaInfo>>(DateTime.UtcNow, list);
  245. _channelItemMediaInfo.AddOrUpdate(id, item2, (key, oldValue) => item2);
  246. return list;
  247. }
  248. public IEnumerable<MediaSourceInfo> GetCachedChannelItemMediaSources(string id)
  249. {
  250. var item = (IChannelMediaItem)_libraryManager.GetItemById(id);
  251. return GetCachedChannelItemMediaSources(item);
  252. }
  253. public IEnumerable<MediaSourceInfo> GetCachedChannelItemMediaSources(IChannelMediaItem item)
  254. {
  255. var filenamePrefix = item.Id.ToString("N");
  256. var parentPath = Path.Combine(ChannelDownloadPath, item.ChannelId);
  257. try
  258. {
  259. var files = new DirectoryInfo(parentPath).EnumerateFiles("*", SearchOption.TopDirectoryOnly);
  260. if (string.Equals(item.MediaType, MediaType.Video, StringComparison.OrdinalIgnoreCase))
  261. {
  262. files = files.Where(i => _libraryManager.IsVideoFile(i.FullName));
  263. }
  264. else
  265. {
  266. files = files.Where(i => _libraryManager.IsAudioFile(i.FullName));
  267. }
  268. var file = files
  269. .FirstOrDefault(i => i.Name.StartsWith(filenamePrefix, StringComparison.OrdinalIgnoreCase));
  270. if (file != null)
  271. {
  272. var cachedItem = _libraryManager.ResolvePath(file);
  273. if (cachedItem != null)
  274. {
  275. var hasMediaSources = _libraryManager.GetItemById(cachedItem.Id) as IHasMediaSources;
  276. if (hasMediaSources != null)
  277. {
  278. var source = hasMediaSources.GetMediaSources(true).FirstOrDefault();
  279. if (source != null)
  280. {
  281. source.Type = MediaSourceType.Cache;
  282. return new[] { source };
  283. }
  284. }
  285. }
  286. }
  287. }
  288. catch (DirectoryNotFoundException)
  289. {
  290. }
  291. return new List<MediaSourceInfo>();
  292. }
  293. private MediaSourceInfo GetMediaSource(IChannelMediaItem item, ChannelMediaInfo info)
  294. {
  295. var source = info.ToMediaSource();
  296. source.RunTimeTicks = source.RunTimeTicks ?? item.RunTimeTicks;
  297. return source;
  298. }
  299. private IEnumerable<ChannelMediaInfo> SortMediaInfoResults(IEnumerable<ChannelMediaInfo> channelMediaSources)
  300. {
  301. var list = channelMediaSources.ToList();
  302. var options = _config.GetChannelsConfiguration();
  303. var width = options.PreferredStreamingWidth;
  304. if (width.HasValue)
  305. {
  306. var val = width.Value;
  307. var res = list
  308. .OrderBy(i => (i.Width.HasValue && i.Width.Value <= val ? 0 : 1))
  309. .ThenBy(i => Math.Abs((i.Width ?? 0) - val))
  310. .ThenByDescending(i => i.Width ?? 0)
  311. .ThenBy(list.IndexOf)
  312. .ToList();
  313. return res;
  314. }
  315. return list
  316. .OrderByDescending(i => i.Width ?? 0)
  317. .ThenBy(list.IndexOf);
  318. }
  319. private async Task<Channel> GetChannel(IChannel channelInfo, CancellationToken cancellationToken)
  320. {
  321. var path = Path.Combine(_config.ApplicationPaths.ItemsByNamePath, "channels", _fileSystem.GetValidFilename(channelInfo.Name));
  322. var fileInfo = new DirectoryInfo(path);
  323. var isNew = false;
  324. if (!fileInfo.Exists)
  325. {
  326. _logger.Debug("Creating directory {0}", path);
  327. Directory.CreateDirectory(path);
  328. fileInfo = new DirectoryInfo(path);
  329. if (!fileInfo.Exists)
  330. {
  331. throw new IOException("Path not created: " + path);
  332. }
  333. isNew = true;
  334. }
  335. var id = GetInternalChannelId(channelInfo.Name);
  336. var item = _libraryManager.GetItemById(id) as Channel;
  337. if (item == null)
  338. {
  339. item = new Channel
  340. {
  341. Name = channelInfo.Name,
  342. Id = id,
  343. DateCreated = _fileSystem.GetCreationTimeUtc(fileInfo),
  344. DateModified = _fileSystem.GetLastWriteTimeUtc(fileInfo),
  345. Path = path
  346. };
  347. isNew = true;
  348. }
  349. item.OfficialRating = GetOfficialRating(channelInfo.ParentalRating);
  350. item.Overview = channelInfo.Description;
  351. item.HomePageUrl = channelInfo.HomePageUrl;
  352. item.OriginalChannelName = channelInfo.Name;
  353. if (string.IsNullOrEmpty(item.Name))
  354. {
  355. item.Name = channelInfo.Name;
  356. }
  357. await item.RefreshMetadata(new MetadataRefreshOptions
  358. {
  359. ForceSave = isNew
  360. }, cancellationToken);
  361. return item;
  362. }
  363. private string GetOfficialRating(ChannelParentalRating rating)
  364. {
  365. switch (rating)
  366. {
  367. case ChannelParentalRating.Adult:
  368. return "XXX";
  369. case ChannelParentalRating.UsR:
  370. return "R";
  371. case ChannelParentalRating.UsPG13:
  372. return "PG-13";
  373. case ChannelParentalRating.UsPG:
  374. return "PG";
  375. default:
  376. return null;
  377. }
  378. }
  379. public Channel GetChannel(string id)
  380. {
  381. return (Channel)_libraryManager.GetItemById(new Guid(id));
  382. }
  383. public IEnumerable<ChannelFeatures> GetAllChannelFeatures()
  384. {
  385. return GetAllChannels()
  386. .Select(GetChannelEntity)
  387. .OrderBy(i => i.SortName)
  388. .Select(i => GetChannelFeatures(i.Id.ToString("N")));
  389. }
  390. public ChannelFeatures GetChannelFeatures(string id)
  391. {
  392. var channel = GetChannel(id);
  393. var channelProvider = GetChannelProvider(channel);
  394. return GetChannelFeaturesDto(channel, channelProvider, channelProvider.GetChannelFeatures());
  395. }
  396. public ChannelFeatures GetChannelFeaturesDto(Channel channel,
  397. IChannel provider,
  398. InternalChannelFeatures features)
  399. {
  400. var isIndexable = provider is IIndexableChannel;
  401. var supportsLatest = provider is ISupportsLatestMedia;
  402. return new ChannelFeatures
  403. {
  404. CanFilter = !features.MaxPageSize.HasValue,
  405. CanSearch = provider is ISearchableChannel,
  406. ContentTypes = features.ContentTypes,
  407. DefaultSortFields = features.DefaultSortFields,
  408. MaxPageSize = features.MaxPageSize,
  409. MediaTypes = features.MediaTypes,
  410. SupportsSortOrderToggle = features.SupportsSortOrderToggle,
  411. SupportsLatestMedia = supportsLatest,
  412. Name = channel.Name,
  413. Id = channel.Id.ToString("N"),
  414. SupportsContentDownloading = isIndexable || supportsLatest,
  415. AutoRefreshLevels = features.AutoRefreshLevels
  416. };
  417. }
  418. private Guid GetInternalChannelId(string name)
  419. {
  420. if (string.IsNullOrWhiteSpace(name))
  421. {
  422. throw new ArgumentNullException("name");
  423. }
  424. return ("Channel " + name).GetMBId(typeof(Channel));
  425. }
  426. public async Task<QueryResult<BaseItemDto>> GetLatestChannelItems(AllChannelMediaQuery query, CancellationToken cancellationToken)
  427. {
  428. var user = string.IsNullOrWhiteSpace(query.UserId)
  429. ? null
  430. : _userManager.GetUserById(query.UserId);
  431. // See below about parental control
  432. if (user != null)
  433. {
  434. query.StartIndex = null;
  435. }
  436. var internalResult = await GetLatestChannelItemsInternal(query, cancellationToken).ConfigureAwait(false);
  437. // Get everything
  438. var fields = Enum.GetNames(typeof(ItemFields))
  439. .Select(i => (ItemFields)Enum.Parse(typeof(ItemFields), i, true))
  440. .ToList();
  441. var items = internalResult.Items;
  442. var totalRecordCount = internalResult.TotalRecordCount;
  443. // Supporting parental control is a hack because it has to be done after querying the remote data source
  444. // This will get screwy if apps try to page, so limit to 10 results in an attempt to always keep them on the first page
  445. if (user != null)
  446. {
  447. items = items.Where(i => i.IsVisible(user))
  448. .Take(10)
  449. .ToArray();
  450. totalRecordCount = items.Length;
  451. }
  452. var returnItems = items.Select(i => _dtoService.GetBaseItemDto(i, fields, user))
  453. .ToArray();
  454. var result = new QueryResult<BaseItemDto>
  455. {
  456. Items = returnItems,
  457. TotalRecordCount = totalRecordCount
  458. };
  459. return result;
  460. }
  461. public async Task<QueryResult<BaseItem>> GetLatestChannelItemsInternal(AllChannelMediaQuery query, CancellationToken cancellationToken)
  462. {
  463. var user = string.IsNullOrWhiteSpace(query.UserId)
  464. ? null
  465. : _userManager.GetUserById(query.UserId);
  466. if (!string.IsNullOrWhiteSpace(query.UserId) && user == null)
  467. {
  468. throw new ArgumentException("User not found.");
  469. }
  470. var channels = GetAllChannels();
  471. if (query.ChannelIds.Length > 0)
  472. {
  473. // Avoid implicitly captured closure
  474. var ids = query.ChannelIds;
  475. channels = channels
  476. .Where(i => ids.Contains(GetInternalChannelId(i.Name).ToString("N")))
  477. .ToArray();
  478. }
  479. // Avoid implicitly captured closure
  480. var userId = query.UserId;
  481. var tasks = channels
  482. .Select(async i =>
  483. {
  484. var indexable = i as ISupportsLatestMedia;
  485. if (indexable != null)
  486. {
  487. try
  488. {
  489. var result = await GetLatestItems(indexable, i, userId, cancellationToken).ConfigureAwait(false);
  490. var resultItems = result.ToList();
  491. return new Tuple<IChannel, ChannelItemResult>(i, new ChannelItemResult
  492. {
  493. Items = resultItems,
  494. TotalRecordCount = resultItems.Count
  495. });
  496. }
  497. catch (Exception ex)
  498. {
  499. _logger.ErrorException("Error getting all media from {0}", ex, i.Name);
  500. }
  501. }
  502. return new Tuple<IChannel, ChannelItemResult>(i, new ChannelItemResult { });
  503. });
  504. var results = await Task.WhenAll(tasks).ConfigureAwait(false);
  505. var totalCount = results.Length;
  506. IEnumerable<Tuple<IChannel, ChannelItemInfo>> items = results
  507. .SelectMany(i => i.Item2.Items.Select(m => new Tuple<IChannel, ChannelItemInfo>(i.Item1, m)));
  508. if (query.ContentTypes.Length > 0)
  509. {
  510. // Avoid implicitly captured closure
  511. var contentTypes = query.ContentTypes;
  512. items = items.Where(i => contentTypes.Contains(i.Item2.ContentType));
  513. }
  514. if (query.ExtraTypes.Length > 0)
  515. {
  516. // Avoid implicitly captured closure
  517. var contentTypes = query.ExtraTypes;
  518. items = items.Where(i => contentTypes.Contains(i.Item2.ExtraType));
  519. }
  520. // Avoid implicitly captured closure
  521. var token = cancellationToken;
  522. var itemTasks = items.Select(i =>
  523. {
  524. var channelProvider = i.Item1;
  525. var internalChannelId = GetInternalChannelId(channelProvider.Name);
  526. return GetChannelItemEntity(i.Item2, channelProvider, internalChannelId, token);
  527. });
  528. var internalItems = await Task.WhenAll(itemTasks).ConfigureAwait(false);
  529. internalItems = ApplyFilters(internalItems, query.Filters, user).ToArray();
  530. await RefreshIfNeeded(internalItems, new Progress<double>(), cancellationToken).ConfigureAwait(false);
  531. if (query.StartIndex.HasValue)
  532. {
  533. internalItems = internalItems.Skip(query.StartIndex.Value).ToArray();
  534. }
  535. if (query.Limit.HasValue)
  536. {
  537. internalItems = internalItems.Take(query.Limit.Value).ToArray();
  538. }
  539. var returnItemArray = internalItems.ToArray();
  540. return new QueryResult<BaseItem>
  541. {
  542. TotalRecordCount = totalCount,
  543. Items = returnItemArray
  544. };
  545. }
  546. private async Task<IEnumerable<ChannelItemInfo>> GetLatestItems(ISupportsLatestMedia indexable, IChannel channel, string userId, CancellationToken cancellationToken)
  547. {
  548. var cacheLength = CacheLength;
  549. var cachePath = GetChannelDataCachePath(channel, userId, "channelmanager-latest", null, false);
  550. try
  551. {
  552. if (_fileSystem.GetLastWriteTimeUtc(cachePath).Add(cacheLength) > DateTime.UtcNow)
  553. {
  554. return _jsonSerializer.DeserializeFromFile<List<ChannelItemInfo>>(cachePath);
  555. }
  556. }
  557. catch (FileNotFoundException)
  558. {
  559. }
  560. catch (DirectoryNotFoundException)
  561. {
  562. }
  563. await _resourcePool.WaitAsync(cancellationToken).ConfigureAwait(false);
  564. try
  565. {
  566. try
  567. {
  568. if (_fileSystem.GetLastWriteTimeUtc(cachePath).Add(cacheLength) > DateTime.UtcNow)
  569. {
  570. return _jsonSerializer.DeserializeFromFile<List<ChannelItemInfo>>(cachePath);
  571. }
  572. }
  573. catch (FileNotFoundException)
  574. {
  575. }
  576. catch (DirectoryNotFoundException)
  577. {
  578. }
  579. var result = await indexable.GetLatestMedia(new ChannelLatestMediaSearch
  580. {
  581. UserId = userId
  582. }, cancellationToken).ConfigureAwait(false);
  583. var resultItems = result.ToList();
  584. CacheResponse(resultItems, cachePath);
  585. return resultItems;
  586. }
  587. finally
  588. {
  589. _resourcePool.Release();
  590. }
  591. }
  592. public async Task<QueryResult<BaseItem>> GetAllMediaInternal(AllChannelMediaQuery query, CancellationToken cancellationToken)
  593. {
  594. var channels = GetAllChannels();
  595. if (query.ChannelIds.Length > 0)
  596. {
  597. // Avoid implicitly captured closure
  598. var ids = query.ChannelIds;
  599. channels = channels
  600. .Where(i => ids.Contains(GetInternalChannelId(i.Name).ToString("N")))
  601. .ToArray();
  602. }
  603. var tasks = channels
  604. .Select(async i =>
  605. {
  606. var indexable = i as IIndexableChannel;
  607. if (indexable != null)
  608. {
  609. try
  610. {
  611. var result = await GetAllItems(indexable, i, new InternalAllChannelMediaQuery
  612. {
  613. UserId = query.UserId,
  614. ContentTypes = query.ContentTypes,
  615. ExtraTypes = query.ExtraTypes,
  616. TrailerTypes = query.TrailerTypes
  617. }, cancellationToken).ConfigureAwait(false);
  618. return new Tuple<IChannel, ChannelItemResult>(i, result);
  619. }
  620. catch (Exception ex)
  621. {
  622. _logger.ErrorException("Error getting all media from {0}", ex, i.Name);
  623. }
  624. }
  625. return new Tuple<IChannel, ChannelItemResult>(i, new ChannelItemResult { });
  626. });
  627. var results = await Task.WhenAll(tasks).ConfigureAwait(false);
  628. var totalCount = results.Length;
  629. IEnumerable<Tuple<IChannel, ChannelItemInfo>> items = results
  630. .SelectMany(i => i.Item2.Items.Select(m => new Tuple<IChannel, ChannelItemInfo>(i.Item1, m)))
  631. .OrderBy(i => i.Item2.Name);
  632. if (query.StartIndex.HasValue)
  633. {
  634. items = items.Skip(query.StartIndex.Value);
  635. }
  636. if (query.Limit.HasValue)
  637. {
  638. items = items.Take(query.Limit.Value);
  639. }
  640. // Avoid implicitly captured closure
  641. var token = cancellationToken;
  642. var itemTasks = items.Select(i =>
  643. {
  644. var channelProvider = i.Item1;
  645. var internalChannelId = GetInternalChannelId(channelProvider.Name);
  646. return GetChannelItemEntity(i.Item2, channelProvider, internalChannelId, token);
  647. });
  648. var internalItems = await Task.WhenAll(itemTasks).ConfigureAwait(false);
  649. var returnItemArray = internalItems.ToArray();
  650. return new QueryResult<BaseItem>
  651. {
  652. TotalRecordCount = totalCount,
  653. Items = returnItemArray
  654. };
  655. }
  656. public async Task<QueryResult<BaseItemDto>> GetAllMedia(AllChannelMediaQuery query, CancellationToken cancellationToken)
  657. {
  658. var user = string.IsNullOrWhiteSpace(query.UserId)
  659. ? null
  660. : _userManager.GetUserById(query.UserId);
  661. var internalResult = await GetAllMediaInternal(query, cancellationToken).ConfigureAwait(false);
  662. await RefreshIfNeeded(internalResult.Items, new Progress<double>(), cancellationToken).ConfigureAwait(false);
  663. // Get everything
  664. var fields = Enum.GetNames(typeof(ItemFields))
  665. .Select(i => (ItemFields)Enum.Parse(typeof(ItemFields), i, true))
  666. .ToList();
  667. var returnItems = internalResult.Items.Select(i => _dtoService.GetBaseItemDto(i, fields, user))
  668. .ToArray();
  669. var result = new QueryResult<BaseItemDto>
  670. {
  671. Items = returnItems,
  672. TotalRecordCount = internalResult.TotalRecordCount
  673. };
  674. return result;
  675. }
  676. private async Task<ChannelItemResult> GetAllItems(IIndexableChannel indexable, IChannel channel, InternalAllChannelMediaQuery query, CancellationToken cancellationToken)
  677. {
  678. var cacheLength = CacheLength;
  679. var folderId = _jsonSerializer.SerializeToString(query).GetMD5().ToString("N");
  680. var cachePath = GetChannelDataCachePath(channel, query.UserId, folderId, null, false);
  681. try
  682. {
  683. if (_fileSystem.GetLastWriteTimeUtc(cachePath).Add(cacheLength) > DateTime.UtcNow)
  684. {
  685. return _jsonSerializer.DeserializeFromFile<ChannelItemResult>(cachePath);
  686. }
  687. }
  688. catch (FileNotFoundException)
  689. {
  690. }
  691. catch (DirectoryNotFoundException)
  692. {
  693. }
  694. await _resourcePool.WaitAsync(cancellationToken).ConfigureAwait(false);
  695. try
  696. {
  697. try
  698. {
  699. if (_fileSystem.GetLastWriteTimeUtc(cachePath).Add(cacheLength) > DateTime.UtcNow)
  700. {
  701. return _jsonSerializer.DeserializeFromFile<ChannelItemResult>(cachePath);
  702. }
  703. }
  704. catch (FileNotFoundException)
  705. {
  706. }
  707. catch (DirectoryNotFoundException)
  708. {
  709. }
  710. var result = await indexable.GetAllMedia(query, cancellationToken).ConfigureAwait(false);
  711. CacheResponse(result, cachePath);
  712. return result;
  713. }
  714. finally
  715. {
  716. _resourcePool.Release();
  717. }
  718. }
  719. public async Task<QueryResult<BaseItem>> GetChannelItemsInternal(ChannelItemQuery query, IProgress<double> progress, CancellationToken cancellationToken)
  720. {
  721. // Get the internal channel entity
  722. var channel = GetChannel(query.ChannelId);
  723. // Find the corresponding channel provider plugin
  724. var channelProvider = GetChannelProvider(channel);
  725. var channelInfo = channelProvider.GetChannelFeatures();
  726. int? providerStartIndex = null;
  727. int? providerLimit = null;
  728. if (channelInfo.MaxPageSize.HasValue)
  729. {
  730. providerStartIndex = query.StartIndex;
  731. if (query.Limit.HasValue && query.Limit.Value > channelInfo.MaxPageSize.Value)
  732. {
  733. throw new ArgumentException(string.Format("{0} channel only supports a maximum of {1} records at a time.", channel.Name, channelInfo.MaxPageSize.Value));
  734. }
  735. providerLimit = query.Limit;
  736. // This will cause some providers to fail
  737. if (providerLimit == 0)
  738. {
  739. providerLimit = 1;
  740. }
  741. }
  742. var user = string.IsNullOrWhiteSpace(query.UserId)
  743. ? null
  744. : _userManager.GetUserById(query.UserId);
  745. ChannelItemSortField? sortField = null;
  746. ChannelItemSortField parsedField;
  747. if (query.SortBy.Length == 1 &&
  748. Enum.TryParse(query.SortBy[0], true, out parsedField))
  749. {
  750. sortField = parsedField;
  751. }
  752. var sortDescending = query.SortOrder.HasValue && query.SortOrder.Value == SortOrder.Descending;
  753. var itemsResult = await GetChannelItems(channelProvider,
  754. user,
  755. query.FolderId,
  756. providerStartIndex,
  757. providerLimit,
  758. sortField,
  759. sortDescending,
  760. cancellationToken)
  761. .ConfigureAwait(false);
  762. var providerTotalRecordCount = providerLimit.HasValue ? itemsResult.TotalRecordCount : null;
  763. var tasks = itemsResult.Items.Select(i => GetChannelItemEntity(i, channelProvider, channel.Id, cancellationToken));
  764. var internalItems = await Task.WhenAll(tasks).ConfigureAwait(false);
  765. if (user != null)
  766. {
  767. internalItems = internalItems.Where(i => i.IsVisible(user)).ToArray();
  768. if (providerTotalRecordCount.HasValue)
  769. {
  770. providerTotalRecordCount = providerTotalRecordCount.Value;
  771. }
  772. }
  773. return await GetReturnItems(internalItems, providerTotalRecordCount, user, query, progress, cancellationToken).ConfigureAwait(false);
  774. }
  775. public async Task<QueryResult<BaseItemDto>> GetChannelItems(ChannelItemQuery query, CancellationToken cancellationToken)
  776. {
  777. var user = string.IsNullOrWhiteSpace(query.UserId)
  778. ? null
  779. : _userManager.GetUserById(query.UserId);
  780. var internalResult = await GetChannelItemsInternal(query, new Progress<double>(), cancellationToken).ConfigureAwait(false);
  781. // Get everything
  782. var fields = Enum.GetNames(typeof(ItemFields))
  783. .Select(i => (ItemFields)Enum.Parse(typeof(ItemFields), i, true))
  784. .ToList();
  785. var returnItems = internalResult.Items.Select(i => _dtoService.GetBaseItemDto(i, fields, user))
  786. .ToArray();
  787. var result = new QueryResult<BaseItemDto>
  788. {
  789. Items = returnItems,
  790. TotalRecordCount = internalResult.TotalRecordCount
  791. };
  792. return result;
  793. }
  794. private readonly SemaphoreSlim _resourcePool = new SemaphoreSlim(1, 1);
  795. private async Task<ChannelItemResult> GetChannelItems(IChannel channel,
  796. User user,
  797. string folderId,
  798. int? startIndex,
  799. int? limit,
  800. ChannelItemSortField? sortField,
  801. bool sortDescending,
  802. CancellationToken cancellationToken)
  803. {
  804. var userId = user.Id.ToString("N");
  805. var cacheLength = CacheLength;
  806. var cachePath = GetChannelDataCachePath(channel, userId, folderId, sortField, sortDescending);
  807. try
  808. {
  809. if (!startIndex.HasValue && !limit.HasValue)
  810. {
  811. if (_fileSystem.GetLastWriteTimeUtc(cachePath).Add(cacheLength) > DateTime.UtcNow)
  812. {
  813. return _jsonSerializer.DeserializeFromFile<ChannelItemResult>(cachePath);
  814. }
  815. }
  816. }
  817. catch (FileNotFoundException)
  818. {
  819. }
  820. catch (DirectoryNotFoundException)
  821. {
  822. }
  823. await _resourcePool.WaitAsync(cancellationToken).ConfigureAwait(false);
  824. try
  825. {
  826. try
  827. {
  828. if (!startIndex.HasValue && !limit.HasValue)
  829. {
  830. if (_fileSystem.GetLastWriteTimeUtc(cachePath).Add(cacheLength) > DateTime.UtcNow)
  831. {
  832. return _jsonSerializer.DeserializeFromFile<ChannelItemResult>(cachePath);
  833. }
  834. }
  835. }
  836. catch (FileNotFoundException)
  837. {
  838. }
  839. catch (DirectoryNotFoundException)
  840. {
  841. }
  842. var query = new InternalChannelItemQuery
  843. {
  844. UserId = userId,
  845. StartIndex = startIndex,
  846. Limit = limit,
  847. SortBy = sortField,
  848. SortDescending = sortDescending
  849. };
  850. if (!string.IsNullOrWhiteSpace(folderId))
  851. {
  852. var categoryItem = (IChannelItem)_libraryManager.GetItemById(new Guid(folderId));
  853. query.FolderId = categoryItem.ExternalId;
  854. }
  855. var result = await channel.GetChannelItems(query, cancellationToken).ConfigureAwait(false);
  856. if (!startIndex.HasValue && !limit.HasValue)
  857. {
  858. CacheResponse(result, cachePath);
  859. }
  860. return result;
  861. }
  862. finally
  863. {
  864. _resourcePool.Release();
  865. }
  866. }
  867. private void CacheResponse(object result, string path)
  868. {
  869. try
  870. {
  871. Directory.CreateDirectory(Path.GetDirectoryName(path));
  872. _jsonSerializer.SerializeToFile(result, path);
  873. }
  874. catch (Exception ex)
  875. {
  876. _logger.ErrorException("Error writing to channel cache file: {0}", ex, path);
  877. }
  878. }
  879. private string GetChannelDataCachePath(IChannel channel,
  880. string userId,
  881. string folderId,
  882. ChannelItemSortField? sortField,
  883. bool sortDescending)
  884. {
  885. var channelId = GetInternalChannelId(channel.Name).ToString("N");
  886. var userCacheKey = string.Empty;
  887. var hasCacheKey = channel as IHasCacheKey;
  888. if (hasCacheKey != null)
  889. {
  890. userCacheKey = hasCacheKey.GetCacheKey(userId) ?? string.Empty;
  891. }
  892. var filename = string.IsNullOrWhiteSpace(folderId) ? "root" : folderId;
  893. filename += userCacheKey;
  894. var version = (channel.DataVersion ?? string.Empty).GetMD5().ToString("N");
  895. if (sortField.HasValue)
  896. {
  897. filename += "-sortField-" + sortField.Value;
  898. }
  899. if (sortDescending)
  900. {
  901. filename += "-sortDescending";
  902. }
  903. filename = filename.GetMD5().ToString("N");
  904. return Path.Combine(_config.ApplicationPaths.CachePath,
  905. "channels",
  906. channelId,
  907. version,
  908. filename + ".json");
  909. }
  910. private async Task<QueryResult<BaseItem>> GetReturnItems(IEnumerable<BaseItem> items,
  911. int? totalCountFromProvider,
  912. User user,
  913. ChannelItemQuery query,
  914. IProgress<double> progress,
  915. CancellationToken cancellationToken)
  916. {
  917. items = ApplyFilters(items, query.Filters, user);
  918. var sortBy = query.SortBy.Length == 0 ? new[] { ItemSortBy.SortName } : query.SortBy;
  919. items = _libraryManager.Sort(items, user, sortBy, query.SortOrder ?? SortOrder.Ascending);
  920. var all = items.ToList();
  921. var totalCount = totalCountFromProvider ?? all.Count;
  922. if (!totalCountFromProvider.HasValue)
  923. {
  924. if (query.StartIndex.HasValue)
  925. {
  926. all = all.Skip(query.StartIndex.Value).ToList();
  927. }
  928. if (query.Limit.HasValue)
  929. {
  930. all = all.Take(query.Limit.Value).ToList();
  931. }
  932. }
  933. var returnItemArray = all.ToArray();
  934. await RefreshIfNeeded(returnItemArray, progress, cancellationToken).ConfigureAwait(false);
  935. return new QueryResult<BaseItem>
  936. {
  937. Items = returnItemArray,
  938. TotalRecordCount = totalCount
  939. };
  940. }
  941. private string GetIdToHash(string externalId, string channelName)
  942. {
  943. // Increment this as needed to force new downloads
  944. // Incorporate Name because it's being used to convert channel entity to provider
  945. return externalId + (channelName ?? string.Empty) + "16";
  946. }
  947. private T GetItemById<T>(string idString, string channelName, string channnelDataVersion, out bool isNew)
  948. where T : BaseItem, IChannelItem, new()
  949. {
  950. var id = GetIdToHash(idString, channelName).GetMBId(typeof(T));
  951. T item = null;
  952. try
  953. {
  954. item = _libraryManager.GetItemById(id) as T;
  955. }
  956. catch (Exception ex)
  957. {
  958. _logger.ErrorException("Error retrieving channel item from database", ex);
  959. }
  960. if (item == null || !string.Equals(item.DataVersion, channnelDataVersion, StringComparison.Ordinal))
  961. {
  962. item = new T();
  963. isNew = true;
  964. }
  965. else
  966. {
  967. isNew = false;
  968. }
  969. item.DataVersion = channnelDataVersion;
  970. item.Id = id;
  971. return item;
  972. }
  973. private async Task<BaseItem> GetChannelItemEntity(ChannelItemInfo info, IChannel channelProvider, Guid internalChannelId, CancellationToken cancellationToken)
  974. {
  975. BaseItem item;
  976. bool isNew;
  977. if (info.Type == ChannelItemType.Folder)
  978. {
  979. item = GetItemById<ChannelFolderItem>(info.Id, channelProvider.Name, channelProvider.DataVersion, out isNew);
  980. }
  981. else if (info.MediaType == ChannelMediaType.Audio)
  982. {
  983. item = GetItemById<ChannelAudioItem>(info.Id, channelProvider.Name, channelProvider.DataVersion, out isNew);
  984. }
  985. else
  986. {
  987. item = GetItemById<ChannelVideoItem>(info.Id, channelProvider.Name, channelProvider.DataVersion, out isNew);
  988. }
  989. item.RunTimeTicks = info.RunTimeTicks;
  990. if (isNew)
  991. {
  992. item.Name = info.Name;
  993. item.Genres = info.Genres;
  994. item.Studios = info.Studios;
  995. item.CommunityRating = info.CommunityRating;
  996. item.Overview = info.Overview;
  997. item.IndexNumber = info.IndexNumber;
  998. item.ParentIndexNumber = info.ParentIndexNumber;
  999. item.People = info.People;
  1000. item.PremiereDate = info.PremiereDate;
  1001. item.ProductionYear = info.ProductionYear;
  1002. item.ProviderIds = info.ProviderIds;
  1003. item.OfficialRating = info.OfficialRating;
  1004. item.DateCreated = info.DateCreated.HasValue ?
  1005. info.DateCreated.Value :
  1006. DateTime.UtcNow;
  1007. }
  1008. var channelItem = (IChannelItem)item;
  1009. channelItem.OriginalImageUrl = info.ImageUrl;
  1010. channelItem.ExternalId = info.Id;
  1011. channelItem.ChannelId = internalChannelId.ToString("N");
  1012. channelItem.ChannelItemType = info.Type;
  1013. if (isNew)
  1014. {
  1015. channelItem.Tags = info.Tags;
  1016. }
  1017. var channelMediaItem = item as IChannelMediaItem;
  1018. if (channelMediaItem != null)
  1019. {
  1020. channelMediaItem.ContentType = info.ContentType;
  1021. channelMediaItem.ExtraType = info.ExtraType;
  1022. channelMediaItem.ChannelMediaSources = info.MediaSources;
  1023. var mediaSource = info.MediaSources.FirstOrDefault();
  1024. item.Path = mediaSource == null ? null : mediaSource.Path;
  1025. item.DisplayMediaType = channelMediaItem.ContentType.ToString();
  1026. }
  1027. if (isNew)
  1028. {
  1029. await _libraryManager.CreateItem(item, cancellationToken).ConfigureAwait(false);
  1030. _libraryManager.RegisterItem(item);
  1031. }
  1032. return item;
  1033. }
  1034. private async Task RefreshIfNeeded(BaseItem[] programs, IProgress<double> progress, CancellationToken cancellationToken)
  1035. {
  1036. var numComplete = 0;
  1037. var numItems = programs.Length;
  1038. foreach (var program in programs)
  1039. {
  1040. await RefreshIfNeeded(program, cancellationToken).ConfigureAwait(false);
  1041. numComplete++;
  1042. double percent = numComplete;
  1043. percent /= numItems;
  1044. progress.Report(percent * 100);
  1045. }
  1046. }
  1047. private async Task RefreshIfNeeded(BaseItem program, CancellationToken cancellationToken)
  1048. {
  1049. if (_refreshedItems.ContainsKey(program.Id))
  1050. {
  1051. return;
  1052. }
  1053. await program.RefreshMetadata(cancellationToken).ConfigureAwait(false);
  1054. _refreshedItems.TryAdd(program.Id, true);
  1055. }
  1056. internal IChannel GetChannelProvider(Channel channel)
  1057. {
  1058. return GetAllChannels().First(i => string.Equals(i.Name, channel.OriginalChannelName, StringComparison.OrdinalIgnoreCase));
  1059. }
  1060. private IEnumerable<BaseItem> ApplyFilters(IEnumerable<BaseItem> items, IEnumerable<ItemFilter> filters, User user)
  1061. {
  1062. foreach (var filter in filters.OrderByDescending(f => (int)f))
  1063. {
  1064. items = ApplyFilter(items, filter, user);
  1065. }
  1066. return items;
  1067. }
  1068. private IEnumerable<BaseItem> ApplyFilter(IEnumerable<BaseItem> items, ItemFilter filter, User user)
  1069. {
  1070. // Avoid implicitly captured closure
  1071. var currentUser = user;
  1072. switch (filter)
  1073. {
  1074. case ItemFilter.IsFavoriteOrLikes:
  1075. return items.Where(item =>
  1076. {
  1077. var userdata = _userDataManager.GetUserData(user.Id, item.GetUserDataKey());
  1078. if (userdata == null)
  1079. {
  1080. return false;
  1081. }
  1082. var likes = userdata.Likes ?? false;
  1083. var favorite = userdata.IsFavorite;
  1084. return likes || favorite;
  1085. });
  1086. case ItemFilter.Likes:
  1087. return items.Where(item =>
  1088. {
  1089. var userdata = _userDataManager.GetUserData(user.Id, item.GetUserDataKey());
  1090. return userdata != null && userdata.Likes.HasValue && userdata.Likes.Value;
  1091. });
  1092. case ItemFilter.Dislikes:
  1093. return items.Where(item =>
  1094. {
  1095. var userdata = _userDataManager.GetUserData(user.Id, item.GetUserDataKey());
  1096. return userdata != null && userdata.Likes.HasValue && !userdata.Likes.Value;
  1097. });
  1098. case ItemFilter.IsFavorite:
  1099. return items.Where(item =>
  1100. {
  1101. var userdata = _userDataManager.GetUserData(user.Id, item.GetUserDataKey());
  1102. return userdata != null && userdata.IsFavorite;
  1103. });
  1104. case ItemFilter.IsResumable:
  1105. return items.Where(item =>
  1106. {
  1107. var userdata = _userDataManager.GetUserData(user.Id, item.GetUserDataKey());
  1108. return userdata != null && userdata.PlaybackPositionTicks > 0;
  1109. });
  1110. case ItemFilter.IsPlayed:
  1111. return items.Where(item => item.IsPlayed(currentUser));
  1112. case ItemFilter.IsUnplayed:
  1113. return items.Where(item => item.IsUnplayed(currentUser));
  1114. case ItemFilter.IsFolder:
  1115. return items.Where(item => item.IsFolder);
  1116. case ItemFilter.IsNotFolder:
  1117. return items.Where(item => !item.IsFolder);
  1118. }
  1119. return items;
  1120. }
  1121. public async Task<BaseItemDto> GetChannelFolder(string userId, CancellationToken cancellationToken)
  1122. {
  1123. var user = string.IsNullOrEmpty(userId) ? null : _userManager.GetUserById(userId);
  1124. // Get everything
  1125. var fields = Enum.GetNames(typeof(ItemFields)).Select(i => (ItemFields)Enum.Parse(typeof(ItemFields), i, true)).ToList();
  1126. var folder = await GetInternalChannelFolder(userId, cancellationToken).ConfigureAwait(false);
  1127. return _dtoService.GetBaseItemDto(folder, fields, user);
  1128. }
  1129. public async Task<Folder> GetInternalChannelFolder(string userId, CancellationToken cancellationToken)
  1130. {
  1131. var name = _localization.GetLocalizedString("ViewTypeChannels");
  1132. return await _libraryManager.GetNamedView(name, "channels", "zz_" + name, cancellationToken).ConfigureAwait(false);
  1133. }
  1134. public async Task DownloadChannelItem(IChannelMediaItem item, string destination,
  1135. IProgress<double> progress, CancellationToken cancellationToken)
  1136. {
  1137. var itemId = item.Id.ToString("N");
  1138. var sources = await GetChannelItemMediaSources(itemId, true, cancellationToken)
  1139. .ConfigureAwait(false);
  1140. var list = sources.Where(i => i.Protocol == MediaProtocol.Http).ToList();
  1141. foreach (var source in list)
  1142. {
  1143. try
  1144. {
  1145. await TryDownloadChannelItem(source, item, destination, progress, cancellationToken).ConfigureAwait(false);
  1146. return;
  1147. }
  1148. catch (HttpException ex)
  1149. {
  1150. if (ex.StatusCode.HasValue && ex.StatusCode.Value == HttpStatusCode.NotFound)
  1151. {
  1152. MarkBadMediaSource(source);
  1153. }
  1154. }
  1155. }
  1156. }
  1157. private async Task TryDownloadChannelItem(MediaSourceInfo source,
  1158. IChannelMediaItem item,
  1159. string destination,
  1160. IProgress<double> progress,
  1161. CancellationToken cancellationToken)
  1162. {
  1163. var options = new HttpRequestOptions
  1164. {
  1165. CancellationToken = cancellationToken,
  1166. Url = source.Path,
  1167. Progress = new Progress<double>()
  1168. };
  1169. var host = new Uri(source.Path).Host.ToLower();
  1170. var channel = GetChannel(item.ChannelId);
  1171. var channelProvider = GetChannelProvider(channel);
  1172. var limit = channelProvider.GetChannelFeatures().DailyDownloadLimit;
  1173. if (!ValidateDownloadLimit(host, limit))
  1174. {
  1175. _logger.Error(string.Format("Download limit has been reached for {0}", channel.Name));
  1176. throw new ChannelDownloadException(string.Format("Download limit has been reached for {0}", channel.Name));
  1177. }
  1178. foreach (var header in source.RequiredHttpHeaders)
  1179. {
  1180. options.RequestHeaders[header.Key] = header.Value;
  1181. }
  1182. Directory.CreateDirectory(Path.GetDirectoryName(destination));
  1183. // Determine output extension
  1184. var response = await _httpClient.GetTempFileResponse(options).ConfigureAwait(false);
  1185. if (response.ContentType.StartsWith("text/html"))
  1186. {
  1187. throw new HttpException("File not found")
  1188. {
  1189. StatusCode = HttpStatusCode.NotFound
  1190. };
  1191. }
  1192. IncrementDownloadCount(host, limit);
  1193. if (string.Equals(item.MediaType, MediaType.Video, StringComparison.OrdinalIgnoreCase) && response.ContentType.StartsWith("video/", StringComparison.OrdinalIgnoreCase))
  1194. {
  1195. var extension = response.ContentType.Split('/')
  1196. .Last()
  1197. .Replace("quicktime", "mov", StringComparison.OrdinalIgnoreCase);
  1198. destination += "." + extension;
  1199. }
  1200. else if (string.Equals(item.MediaType, MediaType.Audio, StringComparison.OrdinalIgnoreCase) && response.ContentType.StartsWith("audio/", StringComparison.OrdinalIgnoreCase))
  1201. {
  1202. var extension = response.ContentType.Replace("audio/mpeg", "audio/mp3", StringComparison.OrdinalIgnoreCase)
  1203. .Split('/')
  1204. .Last();
  1205. destination += "." + extension;
  1206. }
  1207. else
  1208. {
  1209. File.Delete(response.TempFilePath);
  1210. throw new ApplicationException("Unexpected response type encountered: " + response.ContentType);
  1211. }
  1212. File.Copy(response.TempFilePath, destination, true);
  1213. try
  1214. {
  1215. File.Delete(response.TempFilePath);
  1216. }
  1217. catch
  1218. {
  1219. }
  1220. }
  1221. private readonly ReaderWriterLockSlim _mediaSourceHistoryLock = new ReaderWriterLockSlim();
  1222. private bool IsValidMediaSource(MediaSourceInfo source)
  1223. {
  1224. if (source.Protocol == MediaProtocol.Http)
  1225. {
  1226. return !GetBadMediaSourceHistory().Contains(source.Path, StringComparer.OrdinalIgnoreCase);
  1227. }
  1228. return true;
  1229. }
  1230. private void MarkBadMediaSource(MediaSourceInfo source)
  1231. {
  1232. var list = GetBadMediaSourceHistory();
  1233. list.Add(source.Path);
  1234. var path = GetMediaSourceHistoryPath();
  1235. Directory.CreateDirectory(Path.GetDirectoryName(path));
  1236. if (_mediaSourceHistoryLock.TryEnterWriteLock(TimeSpan.FromSeconds(5)))
  1237. {
  1238. try
  1239. {
  1240. File.WriteAllLines(path, list.ToArray(), Encoding.UTF8);
  1241. }
  1242. catch (Exception ex)
  1243. {
  1244. _logger.ErrorException("Error saving file", ex);
  1245. }
  1246. finally
  1247. {
  1248. _mediaSourceHistoryLock.ExitWriteLock();
  1249. }
  1250. }
  1251. }
  1252. private ConcurrentBag<string> _badMediaSources = null;
  1253. private ConcurrentBag<string> GetBadMediaSourceHistory()
  1254. {
  1255. if (_badMediaSources == null)
  1256. {
  1257. var path = GetMediaSourceHistoryPath();
  1258. if (_mediaSourceHistoryLock.TryEnterReadLock(TimeSpan.FromSeconds(1)))
  1259. {
  1260. if (_badMediaSources == null)
  1261. {
  1262. try
  1263. {
  1264. _badMediaSources = new ConcurrentBag<string>(File.ReadAllLines(path, Encoding.UTF8));
  1265. }
  1266. catch (IOException)
  1267. {
  1268. _badMediaSources = new ConcurrentBag<string>();
  1269. }
  1270. catch (Exception ex)
  1271. {
  1272. _logger.ErrorException("Error reading file", ex);
  1273. _badMediaSources = new ConcurrentBag<string>();
  1274. }
  1275. finally
  1276. {
  1277. _mediaSourceHistoryLock.ExitReadLock();
  1278. }
  1279. }
  1280. }
  1281. }
  1282. return _badMediaSources;
  1283. }
  1284. private string GetMediaSourceHistoryPath()
  1285. {
  1286. return Path.Combine(_config.ApplicationPaths.DataPath, "channels", "failures.txt");
  1287. }
  1288. private void IncrementDownloadCount(string key, int? limit)
  1289. {
  1290. if (!limit.HasValue)
  1291. {
  1292. return;
  1293. }
  1294. int current;
  1295. _downloadCounts.TryGetValue(key, out current);
  1296. current++;
  1297. _downloadCounts.AddOrUpdate(key, current, (k, v) => current);
  1298. }
  1299. private bool ValidateDownloadLimit(string key, int? limit)
  1300. {
  1301. if (!limit.HasValue)
  1302. {
  1303. return true;
  1304. }
  1305. int current;
  1306. _downloadCounts.TryGetValue(key, out current);
  1307. return current < limit.Value;
  1308. }
  1309. public void Dispose()
  1310. {
  1311. if (_clearDownloadCountsTimer != null)
  1312. {
  1313. _clearDownloadCountsTimer.Dispose();
  1314. _clearDownloadCountsTimer = null;
  1315. }
  1316. if (_refreshTimer != null)
  1317. {
  1318. _refreshTimer.Dispose();
  1319. _refreshTimer = null;
  1320. }
  1321. }
  1322. }
  1323. }