jellyfin-server/MediaBrowser.Server.Implementations/LiveTv/LiveTvManager.cs

2442 lines
87 KiB
C#
Raw Normal View History

2015-08-19 23:57:27 +00:00
using MediaBrowser.Common;
2014-10-30 01:17:31 +00:00
using MediaBrowser.Common.Configuration;
2014-07-27 22:01:29 +00:00
using MediaBrowser.Common.Extensions;
2015-08-18 15:25:57 +00:00
using MediaBrowser.Common.IO;
2015-02-10 19:47:54 +00:00
using MediaBrowser.Common.Progress;
2014-01-15 05:38:08 +00:00
using MediaBrowser.Common.ScheduledTasks;
2014-01-12 16:55:38 +00:00
using MediaBrowser.Controller.Configuration;
2013-11-24 20:51:45 +00:00
using MediaBrowser.Controller.Drawing;
2013-11-26 02:53:48 +00:00
using MediaBrowser.Controller.Dto;
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Library;
2013-11-24 20:51:45 +00:00
using MediaBrowser.Controller.LiveTv;
2014-06-07 19:46:24 +00:00
using MediaBrowser.Controller.Localization;
2013-11-24 20:51:45 +00:00
using MediaBrowser.Controller.Persistence;
using MediaBrowser.Controller.Providers;
2014-01-13 16:25:18 +00:00
using MediaBrowser.Controller.Sorting;
2015-07-28 12:33:30 +00:00
using MediaBrowser.Model.Configuration;
2014-06-07 19:46:24 +00:00
using MediaBrowser.Model.Dto;
using MediaBrowser.Model.Entities;
using MediaBrowser.Model.LiveTv;
2013-11-24 20:51:45 +00:00
using MediaBrowser.Model.Logging;
2013-11-25 21:53:06 +00:00
using MediaBrowser.Model.Querying;
2014-08-15 16:35:41 +00:00
using MediaBrowser.Model.Serialization;
2015-08-12 21:39:02 +00:00
using MoreLinq;
2013-11-24 20:51:45 +00:00
using System;
2014-01-12 06:31:21 +00:00
using System.Collections.Concurrent;
using System.Collections.Generic;
2015-08-19 23:57:27 +00:00
using System.IO;
2013-11-24 20:51:45 +00:00
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
2015-10-04 04:23:11 +00:00
using CommonIO;
namespace MediaBrowser.Server.Implementations.LiveTv
{
/// <summary>
/// Class LiveTvManager
/// </summary>
2014-01-12 06:31:21 +00:00
public class LiveTvManager : ILiveTvManager, IDisposable
{
2014-01-12 16:55:38 +00:00
private readonly IServerConfigurationManager _config;
2013-11-24 20:51:45 +00:00
private readonly ILogger _logger;
private readonly IItemRepository _itemRepo;
2013-11-26 02:53:48 +00:00
private readonly IUserManager _userManager;
2014-01-12 15:58:47 +00:00
private readonly IUserDataManager _userDataManager;
2014-01-11 05:49:18 +00:00
private readonly ILibraryManager _libraryManager;
2014-01-15 05:38:08 +00:00
private readonly ITaskManager _taskManager;
2014-08-15 16:35:41 +00:00
private readonly IJsonSerializer _jsonSerializer;
2015-03-14 20:00:32 +00:00
private readonly IProviderManager _providerManager;
2013-12-15 01:17:57 +00:00
2014-06-07 19:46:24 +00:00
private readonly IDtoService _dtoService;
private readonly ILocalizationManager _localization;
2013-12-15 01:17:57 +00:00
private readonly LiveTvDtoService _tvDtoService;
2013-11-26 02:53:48 +00:00
private readonly List<ILiveTvService> _services = new List<ILiveTvService>();
2013-11-24 20:51:45 +00:00
2014-07-02 18:34:08 +00:00
private readonly ConcurrentDictionary<string, LiveStreamData> _openStreams =
new ConcurrentDictionary<string, LiveStreamData>();
2014-01-12 06:31:21 +00:00
2015-06-01 17:07:55 +00:00
private readonly SemaphoreSlim _refreshRecordingsLock = new SemaphoreSlim(1, 1);
2015-07-23 13:23:22 +00:00
private readonly List<ITunerHost> _tunerHosts = new List<ITunerHost>();
private readonly List<IListingsProvider> _listingProviders = new List<IListingsProvider>();
2015-08-18 15:25:57 +00:00
private readonly IFileSystem _fileSystem;
2015-07-23 13:23:22 +00:00
2015-08-18 15:25:57 +00:00
public LiveTvManager(IApplicationHost appHost, IServerConfigurationManager config, ILogger logger, IItemRepository itemRepo, IImageProcessor imageProcessor, IUserDataManager userDataManager, IDtoService dtoService, IUserManager userManager, ILibraryManager libraryManager, ITaskManager taskManager, ILocalizationManager localization, IJsonSerializer jsonSerializer, IProviderManager providerManager, IFileSystem fileSystem)
2013-11-24 20:51:45 +00:00
{
2014-01-12 16:55:38 +00:00
_config = config;
2013-11-24 20:51:45 +00:00
_logger = logger;
_itemRepo = itemRepo;
2013-12-15 01:17:57 +00:00
_userManager = userManager;
2014-01-11 05:49:18 +00:00
_libraryManager = libraryManager;
_taskManager = taskManager;
2014-06-07 19:46:24 +00:00
_localization = localization;
2014-08-15 16:35:41 +00:00
_jsonSerializer = jsonSerializer;
2015-03-14 20:00:32 +00:00
_providerManager = providerManager;
2015-08-18 15:25:57 +00:00
_fileSystem = fileSystem;
2014-06-07 19:46:24 +00:00
_dtoService = dtoService;
2014-01-12 15:58:47 +00:00
_userDataManager = userDataManager;
2013-12-15 01:17:57 +00:00
2014-10-30 01:17:31 +00:00
_tvDtoService = new LiveTvDtoService(dtoService, userDataManager, imageProcessor, logger, appHost);
2013-11-24 20:51:45 +00:00
}
/// <summary>
/// Gets the services.
/// </summary>
/// <value>The services.</value>
public IReadOnlyList<ILiveTvService> Services
{
get { return _services; }
}
2014-07-27 22:01:29 +00:00
private LiveTvOptions GetConfiguration()
{
return _config.GetConfiguration<LiveTvOptions>("livetv");
}
/// <summary>
/// Adds the parts.
/// </summary>
/// <param name="services">The services.</param>
2015-07-23 13:23:22 +00:00
/// <param name="tunerHosts">The tuner hosts.</param>
/// <param name="listingProviders">The listing providers.</param>
public void AddParts(IEnumerable<ILiveTvService> services, IEnumerable<ITunerHost> tunerHosts, IEnumerable<IListingsProvider> listingProviders)
{
_services.AddRange(services);
2015-07-23 13:23:22 +00:00
_tunerHosts.AddRange(tunerHosts);
_listingProviders.AddRange(listingProviders);
2013-12-04 20:55:42 +00:00
2015-03-12 15:51:48 +00:00
foreach (var service in _services)
2014-01-15 05:38:08 +00:00
{
service.DataSourceChanged += service_DataSourceChanged;
}
}
2015-07-23 13:23:22 +00:00
public List<ITunerHost> TunerHosts
{
get { return _tunerHosts; }
}
public List<IListingsProvider> ListingProviders
{
get { return _listingProviders; }
}
2014-01-15 05:38:08 +00:00
void service_DataSourceChanged(object sender, EventArgs e)
{
_taskManager.CancelIfRunningAndQueue<RefreshChannelsScheduledTask>();
}
2014-08-14 13:24:30 +00:00
public async Task<QueryResult<LiveTvChannel>> GetInternalChannels(LiveTvChannelQuery query, CancellationToken cancellationToken)
2013-11-24 20:51:45 +00:00
{
2014-09-14 15:10:51 +00:00
var user = string.IsNullOrEmpty(query.UserId) ? null : _userManager.GetUserById(query.UserId);
2013-11-26 02:53:48 +00:00
2015-06-01 14:49:23 +00:00
var channels = _libraryManager.GetItems(new InternalItemsQuery
{
IncludeItemTypes = new[] { typeof(LiveTvChannel).Name }
}).Items.Cast<LiveTvChannel>();
2013-11-26 02:53:48 +00:00
if (user != null)
{
2014-01-03 04:58:22 +00:00
// Avoid implicitly captured closure
var currentUser = user;
2013-12-19 21:51:32 +00:00
channels = channels
2015-02-03 21:06:56 +00:00
.Where(i => i.IsVisible(currentUser))
2013-11-26 02:53:48 +00:00
.OrderBy(i =>
{
double number = 0;
2014-01-23 18:05:41 +00:00
if (!string.IsNullOrEmpty(i.Number))
2013-11-26 02:53:48 +00:00
{
2014-01-23 18:05:41 +00:00
double.TryParse(i.Number, out number);
2013-11-26 02:53:48 +00:00
}
return number;
});
2014-03-29 02:28:02 +00:00
if (query.IsFavorite.HasValue)
{
var val = query.IsFavorite.Value;
channels = channels
.Where(i => _userDataManager.GetUserData(user.Id, i.GetUserDataKey()).IsFavorite == val);
}
if (query.IsLiked.HasValue)
{
var val = query.IsLiked.Value;
channels = channels
.Where(i =>
{
var likes = _userDataManager.GetUserData(user.Id, i.GetUserDataKey()).Likes;
return likes.HasValue && likes.Value == val;
});
}
if (query.IsDisliked.HasValue)
{
var val = query.IsDisliked.Value;
channels = channels
.Where(i =>
{
var likes = _userDataManager.GetUserData(user.Id, i.GetUserDataKey()).Likes;
return likes.HasValue && likes.Value != val;
});
}
2013-11-26 02:53:48 +00:00
}
2014-09-26 03:47:46 +00:00
var enableFavoriteSorting = query.EnableFavoriteSorting;
2014-01-10 13:52:01 +00:00
channels = channels.OrderBy(i =>
2014-09-26 03:47:46 +00:00
{
if (enableFavoriteSorting)
{
var userData = _userDataManager.GetUserData(user.Id, i.GetUserDataKey());
if (userData.IsFavorite)
{
return 0;
}
if (userData.Likes.HasValue)
{
if (!userData.Likes.Value)
{
return 3;
}
return 1;
}
}
return 2;
2014-12-09 04:57:18 +00:00
});
2014-01-10 13:52:01 +00:00
var allChannels = channels.ToList();
IEnumerable<LiveTvChannel> allEnumerable = allChannels;
if (query.StartIndex.HasValue)
{
allEnumerable = allEnumerable.Skip(query.StartIndex.Value);
}
if (query.Limit.HasValue)
{
allEnumerable = allEnumerable.Take(query.Limit.Value);
}
2014-08-14 13:24:30 +00:00
var result = new QueryResult<LiveTvChannel>
{
Items = allEnumerable.ToArray(),
TotalRecordCount = allChannels.Count
};
return result;
}
2015-08-02 17:02:23 +00:00
public async Task<QueryResult<ChannelInfoDto>> GetChannels(LiveTvChannelQuery query, DtoOptions options, CancellationToken cancellationToken)
2014-08-14 13:24:30 +00:00
{
2014-09-14 15:10:51 +00:00
var user = string.IsNullOrEmpty(query.UserId) ? null : _userManager.GetUserById(query.UserId);
2014-08-14 13:24:30 +00:00
var internalResult = await GetInternalChannels(query, cancellationToken).ConfigureAwait(false);
var returnList = new List<ChannelInfoDto>();
2015-06-01 14:49:23 +00:00
var now = DateTime.UtcNow;
2015-08-25 03:13:04 +00:00
var programs = query.AddCurrentProgram ? _libraryManager.QueryItems(new InternalItemsQuery
2015-06-01 14:49:23 +00:00
{
IncludeItemTypes = new[] { typeof(LiveTvProgram).Name },
MaxStartDate = now,
2015-08-25 03:13:04 +00:00
MinEndDate = now,
ChannelIds = internalResult.Items.Select(i => i.Id.ToString("N")).ToArray()
2015-06-01 14:49:23 +00:00
2015-08-25 03:13:04 +00:00
}).Items.Cast<LiveTvProgram>().OrderBy(i => i.StartDate).ToList() : new List<LiveTvProgram>();
2015-06-01 14:49:23 +00:00
2014-08-14 13:24:30 +00:00
foreach (var channel in internalResult.Items)
{
2015-06-01 14:49:23 +00:00
var channelIdString = channel.Id.ToString("N");
var currentProgram = programs.FirstOrDefault(i => string.Equals(i.ChannelId, channelIdString, StringComparison.OrdinalIgnoreCase));
2015-08-02 17:02:23 +00:00
returnList.Add(_tvDtoService.GetChannelInfoDto(channel, options, currentProgram, user));
}
2013-11-25 20:39:23 +00:00
2013-12-15 01:17:57 +00:00
var result = new QueryResult<ChannelInfoDto>
2013-11-25 20:39:23 +00:00
{
Items = returnList.ToArray(),
2014-08-14 13:24:30 +00:00
TotalRecordCount = internalResult.TotalRecordCount
2013-11-25 20:39:23 +00:00
};
2013-12-15 01:17:57 +00:00
return result;
2013-11-24 20:51:45 +00:00
}
2013-12-19 21:51:32 +00:00
public LiveTvChannel GetInternalChannel(string id)
2013-11-24 20:51:45 +00:00
{
2013-12-28 16:58:13 +00:00
return GetInternalChannel(new Guid(id));
}
2013-11-24 21:30:38 +00:00
2013-12-28 16:58:13 +00:00
private LiveTvChannel GetInternalChannel(Guid id)
{
2014-01-11 05:49:18 +00:00
return _libraryManager.GetItemById(id) as LiveTvChannel;
2013-12-22 17:16:24 +00:00
}
2015-05-31 19:12:58 +00:00
internal LiveTvProgram GetInternalProgram(string id)
2013-12-22 17:16:24 +00:00
{
2015-06-01 14:49:23 +00:00
return _libraryManager.GetItemById(id) as LiveTvProgram;
}
2015-06-01 14:49:23 +00:00
internal LiveTvProgram GetInternalProgram(Guid id)
{
2015-06-01 14:49:23 +00:00
return _libraryManager.GetItemById(id) as LiveTvProgram;
}
public async Task<ILiveTvRecording> GetInternalRecording(string id, CancellationToken cancellationToken)
2013-12-19 21:51:32 +00:00
{
2015-03-12 15:51:48 +00:00
var result = await GetInternalRecordings(new RecordingQuery
{
Id = id
2013-12-19 21:51:32 +00:00
2015-03-12 15:51:48 +00:00
}, cancellationToken).ConfigureAwait(false);
2013-12-19 21:51:32 +00:00
2015-03-12 15:51:48 +00:00
return result.Items.FirstOrDefault() as ILiveTvRecording;
2013-12-19 21:51:32 +00:00
}
2013-12-21 18:37:34 +00:00
2014-01-17 16:36:01 +00:00
private readonly SemaphoreSlim _liveStreamSemaphore = new SemaphoreSlim(1, 1);
2015-03-20 05:40:51 +00:00
public async Task<MediaSourceInfo> GetRecordingStream(string id, CancellationToken cancellationToken)
2014-07-02 18:34:08 +00:00
{
2015-05-16 02:36:47 +00:00
return await GetLiveStream(id, null, false, cancellationToken).ConfigureAwait(false);
2014-07-02 18:34:08 +00:00
}
2015-05-16 02:36:47 +00:00
public async Task<MediaSourceInfo> GetChannelStream(string id, string mediaSourceId, CancellationToken cancellationToken)
2014-07-02 18:34:08 +00:00
{
2015-05-16 02:36:47 +00:00
return await GetLiveStream(id, mediaSourceId, true, cancellationToken).ConfigureAwait(false);
2014-07-02 18:34:08 +00:00
}
2015-03-29 04:56:39 +00:00
public async Task<IEnumerable<MediaSourceInfo>> GetRecordingMediaSources(string id, CancellationToken cancellationToken)
{
var item = await GetInternalRecording(id, cancellationToken).ConfigureAwait(false);
var service = GetService(item);
return await service.GetRecordingStreamMediaSources(id, cancellationToken).ConfigureAwait(false);
}
public async Task<IEnumerable<MediaSourceInfo>> GetChannelMediaSources(string id, CancellationToken cancellationToken)
{
var item = GetInternalChannel(id);
var service = GetService(item);
2015-05-18 16:40:20 +00:00
var sources = await service.GetChannelStreamMediaSources(item.ExternalId, cancellationToken).ConfigureAwait(false);
2015-09-01 19:18:25 +00:00
if (sources.Count == 0)
{
throw new NotImplementedException();
}
2015-05-18 16:40:20 +00:00
var list = sources.ToList();
foreach (var source in list)
{
Normalize(source, item.ChannelType == ChannelType.TV);
}
return list;
2015-03-29 04:56:39 +00:00
}
2015-03-12 15:51:48 +00:00
private ILiveTvService GetService(ILiveTvItem item)
{
return GetService(item.ServiceName);
}
private ILiveTvService GetService(string name)
{
return _services.FirstOrDefault(i => string.Equals(i.Name, name, StringComparison.OrdinalIgnoreCase));
}
2015-05-16 02:36:47 +00:00
private async Task<MediaSourceInfo> GetLiveStream(string id, string mediaSourceId, bool isChannel, CancellationToken cancellationToken)
2013-12-22 18:58:51 +00:00
{
2014-01-17 16:36:01 +00:00
await _liveStreamSemaphore.WaitAsync(cancellationToken).ConfigureAwait(false);
2013-12-22 18:58:51 +00:00
2015-09-01 22:04:54 +00:00
if (string.Equals(id, mediaSourceId, StringComparison.OrdinalIgnoreCase))
{
mediaSourceId = null;
}
2014-01-17 16:36:01 +00:00
try
{
2015-03-20 05:40:51 +00:00
MediaSourceInfo info;
2015-03-29 04:56:39 +00:00
bool isVideo;
2014-01-17 16:36:01 +00:00
2014-07-02 18:34:08 +00:00
if (isChannel)
{
var channel = GetInternalChannel(id);
2015-03-27 20:55:31 +00:00
isVideo = channel.ChannelType == ChannelType.TV;
2015-03-12 15:51:48 +00:00
var service = GetService(channel);
2014-07-02 18:34:08 +00:00
_logger.Info("Opening channel stream from {0}, external channel Id: {1}", service.Name, channel.ExternalId);
2015-05-16 02:36:47 +00:00
info = await service.GetChannelStream(channel.ExternalId, mediaSourceId, cancellationToken).ConfigureAwait(false);
2015-03-28 20:22:27 +00:00
info.RequiresClosing = true;
2015-03-29 18:16:40 +00:00
2015-08-02 19:08:55 +00:00
if (info.RequiresClosing)
2015-03-29 18:16:40 +00:00
{
2015-03-30 03:04:55 +00:00
var idPrefix = service.GetType().FullName.GetMD5().ToString("N") + "_";
info.LiveStreamId = idPrefix + info.Id;
2015-03-29 18:16:40 +00:00
}
2014-07-02 18:34:08 +00:00
}
else
{
2015-03-12 15:51:48 +00:00
var recording = await GetInternalRecording(id, cancellationToken).ConfigureAwait(false);
2015-03-27 20:55:31 +00:00
isVideo = !string.Equals(recording.MediaType, MediaType.Audio, StringComparison.OrdinalIgnoreCase);
2015-03-12 15:51:48 +00:00
var service = GetService(recording);
2014-01-12 06:31:21 +00:00
2015-06-01 17:07:55 +00:00
_logger.Info("Opening recording stream from {0}, external recording Id: {1}", service.Name, recording.ExternalId);
info = await service.GetRecordingStream(recording.ExternalId, null, cancellationToken).ConfigureAwait(false);
2015-03-28 20:22:27 +00:00
info.RequiresClosing = true;
2015-03-29 18:16:40 +00:00
2015-08-02 19:08:55 +00:00
if (info.RequiresClosing)
2015-03-29 18:16:40 +00:00
{
2015-03-30 03:04:55 +00:00
var idPrefix = service.GetType().FullName.GetMD5().ToString("N") + "_";
info.LiveStreamId = idPrefix + info.Id;
2015-03-29 18:16:40 +00:00
}
2014-07-02 18:34:08 +00:00
}
2014-06-02 19:32:41 +00:00
2014-08-15 16:35:41 +00:00
_logger.Info("Live stream info: {0}", _jsonSerializer.SerializeToString(info));
2015-03-27 20:55:31 +00:00
Normalize(info, isVideo);
2014-05-27 21:17:48 +00:00
2014-07-02 18:34:08 +00:00
var data = new LiveStreamData
2014-01-17 16:36:01 +00:00
{
2014-07-02 18:34:08 +00:00
Info = info,
IsChannel = isChannel,
ItemId = id
};
2014-01-17 16:36:01 +00:00
2014-07-02 18:34:08 +00:00
_openStreams.AddOrUpdate(info.Id, data, (key, i) => data);
return info;
2014-01-17 16:36:01 +00:00
}
2014-01-19 04:25:01 +00:00
catch (Exception ex)
{
_logger.ErrorException("Error getting channel stream", ex);
throw;
}
2014-01-17 16:36:01 +00:00
finally
2014-01-12 06:31:21 +00:00
{
2014-01-17 16:36:01 +00:00
_liveStreamSemaphore.Release();
2014-01-12 06:31:21 +00:00
}
2013-12-29 18:53:56 +00:00
}
2015-03-27 20:55:31 +00:00
private void Normalize(MediaSourceInfo mediaSource, bool isVideo)
2014-06-02 19:32:41 +00:00
{
2015-03-20 05:40:51 +00:00
if (mediaSource.MediaStreams.Count == 0)
2014-10-15 04:11:40 +00:00
{
2015-03-27 20:55:31 +00:00
if (isVideo)
2015-03-20 05:40:51 +00:00
{
2015-03-27 20:55:31 +00:00
mediaSource.MediaStreams.AddRange(new List<MediaStream>
2015-03-20 05:40:51 +00:00
{
2015-03-27 20:55:31 +00:00
new MediaStream
{
Type = MediaStreamType.Video,
// Set the index to -1 because we don't know the exact index of the video stream within the container
2015-03-29 04:56:39 +00:00
Index = -1,
// Set to true if unknown to enable deinterlacing
IsInterlaced = true
2015-03-27 20:55:31 +00:00
},
new MediaStream
{
Type = MediaStreamType.Audio,
// Set the index to -1 because we don't know the exact index of the audio stream within the container
Index = -1
}
});
}
else
{
mediaSource.MediaStreams.AddRange(new List<MediaStream>
2015-03-20 05:40:51 +00:00
{
2015-03-27 20:55:31 +00:00
new MediaStream
{
Type = MediaStreamType.Audio,
// Set the index to -1 because we don't know the exact index of the audio stream within the container
Index = -1
}
});
}
2014-10-15 04:11:40 +00:00
}
2015-03-20 05:40:51 +00:00
// Clean some bad data coming from providers
foreach (var stream in mediaSource.MediaStreams)
2014-10-15 04:11:40 +00:00
{
2015-03-20 05:40:51 +00:00
if (stream.BitRate.HasValue && stream.BitRate <= 0)
{
stream.BitRate = null;
}
if (stream.Channels.HasValue && stream.Channels <= 0)
{
stream.Channels = null;
}
if (stream.AverageFrameRate.HasValue && stream.AverageFrameRate <= 0)
{
stream.AverageFrameRate = null;
}
if (stream.RealFrameRate.HasValue && stream.RealFrameRate <= 0)
{
stream.RealFrameRate = null;
}
if (stream.Width.HasValue && stream.Width <= 0)
{
stream.Width = null;
}
if (stream.Height.HasValue && stream.Height <= 0)
{
stream.Height = null;
}
if (stream.SampleRate.HasValue && stream.SampleRate <= 0)
{
stream.SampleRate = null;
}
if (stream.Level.HasValue && stream.Level <= 0)
{
stream.Level = null;
}
2014-10-15 04:11:40 +00:00
}
2015-03-20 05:40:51 +00:00
var indexes = mediaSource.MediaStreams.Select(i => i.Index).Distinct().ToList();
// If there are duplicate stream indexes, set them all to unknown
if (indexes.Count != mediaSource.MediaStreams.Count)
2014-10-15 04:11:40 +00:00
{
2015-03-20 05:40:51 +00:00
foreach (var stream in mediaSource.MediaStreams)
{
stream.Index = -1;
}
2014-06-02 19:32:41 +00:00
}
2015-05-16 02:36:47 +00:00
// Set the total bitrate if not already supplied
if (!mediaSource.Bitrate.HasValue)
{
var total = mediaSource.MediaStreams.Select(i => i.BitRate ?? 0).Sum();
if (total > 0)
{
mediaSource.Bitrate = total;
}
}
2014-06-02 19:32:41 +00:00
}
2015-11-22 23:06:11 +00:00
private async Task<LiveTvChannel> GetChannel(ChannelInfo channelInfo, string serviceName, Guid parentFolderId, CancellationToken cancellationToken)
2013-11-24 20:51:45 +00:00
{
var isNew = false;
2013-12-23 03:46:03 +00:00
var id = _tvDtoService.GetInternalChannelId(serviceName, channelInfo.Id);
2013-11-24 20:51:45 +00:00
2013-12-19 21:51:32 +00:00
var item = _itemRepo.RetrieveItem(id) as LiveTvChannel;
2013-11-24 20:51:45 +00:00
2015-01-17 18:15:09 +00:00
if (item == null)
2013-11-24 20:51:45 +00:00
{
2013-12-19 21:51:32 +00:00
item = new LiveTvChannel
2013-11-24 20:51:45 +00:00
{
Name = channelInfo.Name,
Id = id,
2015-01-17 18:15:09 +00:00
DateCreated = DateTime.UtcNow,
2013-11-24 20:51:45 +00:00
};
isNew = true;
}
2015-10-06 02:50:20 +00:00
if (!string.Equals(channelInfo.Id, item.ExternalId))
{
isNew = true;
}
2014-01-23 18:05:41 +00:00
item.ExternalId = channelInfo.Id;
2015-10-06 02:50:20 +00:00
item.ChannelType = channelInfo.ChannelType;
2013-12-19 21:51:32 +00:00
item.ServiceName = serviceName;
2014-01-23 18:05:41 +00:00
item.Number = channelInfo.Number;
2015-07-24 15:20:11 +00:00
//if (!string.Equals(item.ProviderImageUrl, channelInfo.ImageUrl, StringComparison.OrdinalIgnoreCase))
//{
// isNew = true;
// replaceImages.Add(ImageType.Primary);
//}
//if (!string.Equals(item.ProviderImagePath, channelInfo.ImagePath, StringComparison.OrdinalIgnoreCase))
//{
// isNew = true;
// replaceImages.Add(ImageType.Primary);
//}
2014-08-26 02:30:52 +00:00
2015-11-22 23:06:11 +00:00
if (!item.HasImage(ImageType.Primary))
2015-10-25 17:13:30 +00:00
{
2015-11-22 23:06:11 +00:00
if (!string.IsNullOrWhiteSpace(channelInfo.ImagePath))
{
item.SetImagePath(ImageType.Primary, channelInfo.ImagePath);
}
else if (!string.IsNullOrWhiteSpace(channelInfo.ImageUrl))
{
item.SetImagePath(ImageType.Primary, channelInfo.ImageUrl);
}
2015-10-25 17:13:30 +00:00
}
2015-02-10 19:47:54 +00:00
2014-01-23 18:05:41 +00:00
if (string.IsNullOrEmpty(item.Name))
{
item.Name = channelInfo.Name;
}
2013-12-19 21:51:32 +00:00
2015-09-21 16:26:05 +00:00
await item.RefreshMetadata(new MetadataRefreshOptions(_fileSystem)
{
2015-11-22 23:06:11 +00:00
ForceSave = isNew
}, cancellationToken);
2013-11-24 20:51:45 +00:00
return item;
}
2013-11-25 16:15:31 +00:00
2015-11-22 23:06:11 +00:00
private async Task<LiveTvProgram> GetProgram(ProgramInfo info, LiveTvChannel channel, ChannelType channelType, string serviceName, CancellationToken cancellationToken)
2013-12-21 18:37:34 +00:00
{
var id = _tvDtoService.GetInternalProgramId(serviceName, info.Id);
2015-03-16 01:48:25 +00:00
var item = _libraryManager.GetItemById(id) as LiveTvProgram;
2015-06-01 14:49:23 +00:00
var isNew = false;
2015-11-22 23:06:11 +00:00
var forceUpdate = false;
2013-12-21 18:37:34 +00:00
if (item == null)
{
2015-06-01 14:49:23 +00:00
isNew = true;
2013-12-21 18:37:34 +00:00
item = new LiveTvProgram
{
Name = info.Name,
Id = id,
DateCreated = DateTime.UtcNow,
2015-08-22 02:59:10 +00:00
DateModified = DateTime.UtcNow,
2015-10-04 18:10:50 +00:00
ExternalEtag = info.Etag
2013-12-21 18:37:34 +00:00
};
}
2015-11-22 23:06:11 +00:00
//item.ChannelType = channelType;
if (!string.Equals(item.ServiceName, serviceName, StringComparison.Ordinal))
{
forceUpdate = true;
}
2013-12-21 18:37:34 +00:00
item.ServiceName = serviceName;
2014-01-23 18:05:41 +00:00
item.Audio = info.Audio;
2015-11-22 23:06:11 +00:00
item.ChannelId = channel.Id.ToString("N");
2015-06-01 14:49:23 +00:00
item.CommunityRating = item.CommunityRating ?? info.CommunityRating;
2014-01-23 18:05:41 +00:00
item.EndDate = info.EndDate;
item.EpisodeTitle = info.EpisodeTitle;
item.ExternalId = info.Id;
item.Genres = info.Genres;
item.IsHD = info.IsHD;
item.IsKids = info.IsKids;
item.IsLive = info.IsLive;
item.IsMovie = info.IsMovie;
item.IsNews = info.IsNews;
item.IsPremiere = info.IsPremiere;
item.IsRepeat = info.IsRepeat;
item.IsSeries = info.IsSeries;
item.IsSports = info.IsSports;
item.Name = info.Name;
2015-06-01 14:49:23 +00:00
item.OfficialRating = item.OfficialRating ?? info.OfficialRating;
item.Overview = item.Overview ?? info.Overview;
2014-01-23 18:05:41 +00:00
item.RunTimeTicks = (info.EndDate - info.StartDate).Ticks;
item.StartDate = info.StartDate;
2015-08-11 17:47:29 +00:00
item.HomePageUrl = info.HomePageUrl;
2014-01-23 18:05:41 +00:00
2015-03-31 18:50:08 +00:00
item.ProductionYear = info.ProductionYear;
2015-09-29 16:29:06 +00:00
item.PremiereDate = info.OriginalAirDate;
2015-04-16 03:23:13 +00:00
2015-08-19 06:12:58 +00:00
item.IndexNumber = info.EpisodeNumber;
item.ParentIndexNumber = info.SeasonNumber;
2015-11-21 04:44:22 +00:00
if (!item.HasImage(ImageType.Primary))
2015-10-25 17:13:30 +00:00
{
2015-11-21 04:44:22 +00:00
if (!string.IsNullOrWhiteSpace(info.ImagePath))
{
item.SetImage(new ItemImageInfo
{
Path = info.ImagePath,
Type = ImageType.Primary,
IsPlaceholder = true
}, 0);
}
else if (!string.IsNullOrWhiteSpace(info.ImageUrl))
{
item.SetImage(new ItemImageInfo
{
Path = info.ImageUrl,
Type = ImageType.Primary,
IsPlaceholder = true
}, 0);
}
2015-10-25 17:13:30 +00:00
}
2015-11-22 23:06:11 +00:00
2015-06-01 14:49:23 +00:00
if (isNew)
{
await _libraryManager.CreateItem(item, cancellationToken).ConfigureAwait(false);
}
2015-11-22 23:06:11 +00:00
else if (forceUpdate || string.IsNullOrWhiteSpace(info.Etag))
2015-09-21 16:26:05 +00:00
{
await _libraryManager.UpdateItem(item, ItemUpdateType.MetadataImport, cancellationToken).ConfigureAwait(false);
}
2015-06-01 14:49:23 +00:00
else
{
2015-09-21 16:26:05 +00:00
// Increment this whenver some internal change deems it necessary
2015-10-04 18:10:50 +00:00
var etag = info.Etag + "4";
2015-09-21 16:26:05 +00:00
2015-10-04 18:10:50 +00:00
if (!string.Equals(etag, item.ExternalEtag, StringComparison.OrdinalIgnoreCase))
2015-08-22 02:59:10 +00:00
{
2015-10-04 18:10:50 +00:00
item.ExternalEtag = etag;
2015-08-22 02:59:10 +00:00
await _libraryManager.UpdateItem(item, ItemUpdateType.MetadataImport, cancellationToken).ConfigureAwait(false);
}
2015-06-01 14:49:23 +00:00
}
2015-09-21 16:26:05 +00:00
_providerManager.QueueRefresh(item.Id, new MetadataRefreshOptions(_fileSystem));
2015-03-16 01:48:25 +00:00
2013-12-21 18:37:34 +00:00
return item;
}
2015-11-22 23:06:11 +00:00
private async Task<Guid> CreateRecordingRecord(RecordingInfo info, string serviceName, Guid parentFolderId, CancellationToken cancellationToken)
2013-12-19 21:51:32 +00:00
{
var isNew = false;
var id = _tvDtoService.GetInternalRecordingId(serviceName, info.Id);
2015-05-31 18:22:51 +00:00
var item = _itemRepo.RetrieveItem(id);
2013-12-19 21:51:32 +00:00
if (item == null)
{
if (info.ChannelType == ChannelType.TV)
2013-12-19 21:51:32 +00:00
{
item = new LiveTvVideoRecording
{
Name = info.Name,
Id = id,
DateCreated = DateTime.UtcNow,
DateModified = DateTime.UtcNow,
VideoType = VideoType.VideoFile
};
}
else
{
item = new LiveTvAudioRecording
{
Name = info.Name,
Id = id,
DateCreated = DateTime.UtcNow,
DateModified = DateTime.UtcNow
};
}
2013-12-19 21:51:32 +00:00
isNew = true;
}
2015-10-16 22:36:01 +00:00
2015-06-01 17:07:55 +00:00
item.ChannelId = _tvDtoService.GetInternalChannelId(serviceName, info.ChannelId).ToString("N");
2015-05-31 18:22:51 +00:00
item.CommunityRating = info.CommunityRating;
item.OfficialRating = info.OfficialRating;
item.Overview = info.Overview;
item.EndDate = info.EndDate;
2015-06-01 17:07:55 +00:00
item.Genres = info.Genres;
2015-09-29 16:29:06 +00:00
item.PremiereDate = info.OriginalAirDate;
2015-05-31 18:22:51 +00:00
var recording = (ILiveTvRecording)item;
2015-06-04 20:27:46 +00:00
recording.ExternalId = info.Id;
2015-10-29 22:45:07 +00:00
var dataChanged = false;
2015-06-01 17:07:55 +00:00
recording.Audio = info.Audio;
recording.EndDate = info.EndDate;
recording.EpisodeTitle = info.EpisodeTitle;
recording.IsHD = info.IsHD;
recording.IsKids = info.IsKids;
recording.IsLive = info.IsLive;
recording.IsMovie = info.IsMovie;
recording.IsNews = info.IsNews;
recording.IsPremiere = info.IsPremiere;
recording.IsRepeat = info.IsRepeat;
recording.IsSports = info.IsSports;
recording.SeriesTimerId = info.SeriesTimerId;
recording.StartDate = info.StartDate;
2015-10-11 16:12:53 +00:00
2015-10-29 22:45:07 +00:00
if (!dataChanged)
{
dataChanged = recording.IsSeries != info.IsSeries;
}
recording.IsSeries = info.IsSeries;
2015-11-22 23:06:11 +00:00
if (!item.HasImage(ImageType.Primary))
2015-10-25 17:13:30 +00:00
{
2015-11-22 23:06:11 +00:00
if (!string.IsNullOrWhiteSpace(info.ImagePath))
{
item.SetImagePath(ImageType.Primary, info.ImagePath);
}
else if (!string.IsNullOrWhiteSpace(info.ImageUrl))
{
item.SetImagePath(ImageType.Primary, info.ImageUrl);
}
2015-10-25 17:13:30 +00:00
}
2015-10-29 22:45:07 +00:00
2015-10-11 16:12:53 +00:00
var statusChanged = info.Status != recording.Status;
2015-06-01 17:07:55 +00:00
recording.Status = info.Status;
2015-05-31 18:22:51 +00:00
recording.ServiceName = serviceName;
2013-12-19 21:51:32 +00:00
if (!string.IsNullOrEmpty(info.Path))
{
2015-10-29 22:45:07 +00:00
if (!dataChanged)
{
dataChanged = !string.Equals(item.Path, info.Path);
}
2015-10-04 03:38:46 +00:00
var fileInfo = _fileSystem.GetFileInfo(info.Path);
2015-08-18 15:25:57 +00:00
recording.DateCreated = _fileSystem.GetCreationTimeUtc(fileInfo);
recording.DateModified = _fileSystem.GetLastWriteTimeUtc(fileInfo);
2015-10-16 22:36:01 +00:00
item.Path = info.Path;
}
else if (!string.IsNullOrEmpty(info.Url))
{
2015-10-29 22:45:07 +00:00
if (!dataChanged)
{
dataChanged = !string.Equals(item.Path, info.Url);
}
item.Path = info.Url;
}
2015-10-16 22:36:01 +00:00
var metadataRefreshMode = MetadataRefreshMode.Default;
2015-06-01 17:07:55 +00:00
if (isNew)
{
2015-06-01 17:07:55 +00:00
await _libraryManager.CreateItem(item, cancellationToken).ConfigureAwait(false);
}
2015-10-29 22:45:07 +00:00
else if (dataChanged || info.DateLastUpdated > recording.DateLastSaved || statusChanged)
2015-06-01 17:07:55 +00:00
{
2015-10-16 22:36:01 +00:00
metadataRefreshMode = MetadataRefreshMode.FullRefresh;
2015-06-01 17:07:55 +00:00
await _libraryManager.UpdateItem(item, ItemUpdateType.MetadataImport, cancellationToken).ConfigureAwait(false);
}
2013-12-19 21:51:32 +00:00
2015-10-16 22:36:01 +00:00
_providerManager.QueueRefresh(item.Id, new MetadataRefreshOptions(_fileSystem)
{
MetadataRefreshMode = metadataRefreshMode
});
2014-01-11 05:49:18 +00:00
2015-06-01 17:07:55 +00:00
return item.Id;
2013-12-19 21:51:32 +00:00
}
2015-05-31 19:12:58 +00:00
public async Task<BaseItemDto> GetProgram(string id, CancellationToken cancellationToken, User user = null)
2013-12-17 20:02:12 +00:00
{
2015-03-14 20:00:32 +00:00
var program = GetInternalProgram(id);
2013-12-21 18:37:34 +00:00
2015-05-31 19:12:58 +00:00
var dto = _dtoService.GetBaseItemDto(program, new DtoOptions(), user);
2013-12-21 18:37:34 +00:00
2015-11-22 23:06:11 +00:00
var list = new List<Tuple<BaseItemDto, string, string>>();
list.Add(new Tuple<BaseItemDto, string, string>(dto, program.ServiceName, program.ExternalId));
await AddRecordingInfo(list, cancellationToken).ConfigureAwait(false);
2013-12-17 20:02:12 +00:00
2013-12-21 18:37:34 +00:00
return dto;
2013-12-17 20:02:12 +00:00
}
2015-08-02 17:02:23 +00:00
public async Task<QueryResult<BaseItemDto>> GetPrograms(ProgramQuery query, DtoOptions options, CancellationToken cancellationToken)
2013-11-25 16:15:31 +00:00
{
2015-11-22 23:06:11 +00:00
var user = string.IsNullOrEmpty(query.UserId) ? null : _userManager.GetUserById(query.UserId);
2015-06-01 14:49:23 +00:00
var internalQuery = new InternalItemsQuery
2014-01-06 01:59:21 +00:00
{
2015-06-01 14:49:23 +00:00
IncludeItemTypes = new[] { typeof(LiveTvProgram).Name },
MinEndDate = query.MinEndDate,
MinStartDate = query.MinStartDate,
MaxEndDate = query.MaxEndDate,
MaxStartDate = query.MaxStartDate,
ChannelIds = query.ChannelIds,
IsMovie = query.IsMovie,
2015-07-28 12:33:30 +00:00
IsSports = query.IsSports,
2015-08-04 14:26:36 +00:00
IsKids = query.IsKids,
2015-08-25 03:13:04 +00:00
Genres = query.Genres,
StartIndex = query.StartIndex,
Limit = query.Limit,
SortBy = query.SortBy,
SortOrder = query.SortOrder ?? SortOrder.Ascending
2015-06-01 14:49:23 +00:00
};
2014-01-06 01:59:21 +00:00
2015-07-28 12:33:30 +00:00
if (user != null)
{
internalQuery.MaxParentalRating = user.Policy.MaxParentalRating;
if (user.Policy.BlockUnratedItems.Contains(UnratedItem.LiveTvProgram))
{
internalQuery.HasParentalRating = true;
}
}
2015-03-07 03:53:31 +00:00
if (query.HasAired.HasValue)
{
2015-06-01 14:49:23 +00:00
if (query.HasAired.Value)
2013-12-21 18:37:34 +00:00
{
2015-06-01 14:49:23 +00:00
internalQuery.MaxEndDate = DateTime.UtcNow;
}
else
{
internalQuery.MinEndDate = DateTime.UtcNow;
}
2013-11-25 20:39:23 +00:00
}
2015-08-25 03:13:04 +00:00
var queryResult = _libraryManager.QueryItems(internalQuery);
2013-12-21 18:37:34 +00:00
2015-08-25 03:13:04 +00:00
var returnArray = queryResult.Items
2015-11-22 23:06:11 +00:00
.Cast<LiveTvProgram>()
.Select(i => new Tuple<BaseItemDto, string, string>(_dtoService.GetBaseItemDto(i, options, user), i.ServiceName, i.ExternalId))
2013-12-21 18:37:34 +00:00
.ToArray();
await AddRecordingInfo(returnArray, cancellationToken).ConfigureAwait(false);
2013-11-25 20:39:23 +00:00
2015-05-31 19:12:58 +00:00
var result = new QueryResult<BaseItemDto>
2013-11-26 21:36:11 +00:00
{
2015-11-22 23:06:11 +00:00
Items = returnArray.Select(i => i.Item1).ToArray(),
2015-08-25 03:13:04 +00:00
TotalRecordCount = queryResult.TotalRecordCount
2013-11-26 21:36:11 +00:00
};
2013-12-17 20:02:12 +00:00
2013-12-21 18:37:34 +00:00
return result;
}
public async Task<QueryResult<LiveTvProgram>> GetRecommendedProgramsInternal(RecommendedProgramQuery query, CancellationToken cancellationToken)
2014-01-12 15:58:47 +00:00
{
2015-11-22 23:06:11 +00:00
var user = _userManager.GetUserById(query.UserId);
2015-06-01 14:49:23 +00:00
var internalQuery = new InternalItemsQuery
2014-01-12 15:58:47 +00:00
{
2015-06-01 14:49:23 +00:00
IncludeItemTypes = new[] { typeof(LiveTvProgram).Name },
IsAiring = query.IsAiring,
IsMovie = query.IsMovie,
2015-08-04 14:26:36 +00:00
IsSports = query.IsSports,
IsKids = query.IsKids
2015-06-01 14:49:23 +00:00
};
2014-01-12 15:58:47 +00:00
2015-11-22 23:06:11 +00:00
if (user != null)
{
internalQuery.MaxParentalRating = user.Policy.MaxParentalRating;
if (user.Policy.BlockUnratedItems.Contains(UnratedItem.LiveTvProgram))
{
internalQuery.HasParentalRating = true;
}
}
2014-01-12 15:58:47 +00:00
if (query.HasAired.HasValue)
{
2015-06-01 14:49:23 +00:00
if (query.HasAired.Value)
{
internalQuery.MaxEndDate = DateTime.UtcNow;
}
else
{
internalQuery.MinEndDate = DateTime.UtcNow;
}
2014-01-12 15:58:47 +00:00
}
2015-08-19 23:57:27 +00:00
IEnumerable<LiveTvProgram> programs = _libraryManager.QueryItems(internalQuery).Items.Cast<LiveTvProgram>();
2015-04-03 16:31:56 +00:00
2014-01-12 15:58:47 +00:00
var programList = programs.ToList();
var genres = programList.SelectMany(i => i.Genres)
2015-08-12 21:39:02 +00:00
.Where(i => !string.IsNullOrWhiteSpace(i))
2015-04-09 21:11:57 +00:00
.DistinctNames()
2014-01-12 15:58:47 +00:00
.Select(i => _libraryManager.GetGenre(i))
2015-08-12 21:39:02 +00:00
.DistinctBy(i => i.Id)
2014-01-12 15:58:47 +00:00
.ToDictionary(i => i.Name, StringComparer.OrdinalIgnoreCase);
programs = programList.OrderBy(i => i.HasImage(ImageType.Primary) ? 0 : 1)
2015-03-19 16:16:33 +00:00
.ThenByDescending(i => GetRecommendationScore(i, user.Id, genres))
2014-01-23 18:05:41 +00:00
.ThenBy(i => i.StartDate);
2014-01-12 15:58:47 +00:00
if (query.Limit.HasValue)
{
2015-08-24 02:08:20 +00:00
programs = programs.Take(query.Limit.Value);
2014-01-12 15:58:47 +00:00
}
programList = programs.ToList();
var returnArray = programList.ToArray();
var result = new QueryResult<LiveTvProgram>
{
Items = returnArray,
TotalRecordCount = returnArray.Length
};
return result;
}
2015-08-02 17:02:23 +00:00
public async Task<QueryResult<BaseItemDto>> GetRecommendedPrograms(RecommendedProgramQuery query, DtoOptions options, CancellationToken cancellationToken)
{
var internalResult = await GetRecommendedProgramsInternal(query, cancellationToken).ConfigureAwait(false);
2014-09-14 15:10:51 +00:00
var user = _userManager.GetUserById(query.UserId);
var returnArray = internalResult.Items
2015-11-22 23:06:11 +00:00
.Select(i => new Tuple<BaseItemDto, string, string>(_dtoService.GetBaseItemDto(i, options, user), i.ServiceName, i.ExternalId))
2014-01-12 15:58:47 +00:00
.ToArray();
await AddRecordingInfo(returnArray, cancellationToken).ConfigureAwait(false);
2015-05-31 19:12:58 +00:00
var result = new QueryResult<BaseItemDto>
2014-01-12 15:58:47 +00:00
{
2015-11-22 23:06:11 +00:00
Items = returnArray.Select(i => i.Item1).ToArray(),
TotalRecordCount = internalResult.TotalRecordCount
2014-01-12 15:58:47 +00:00
};
return result;
}
2015-03-19 16:16:33 +00:00
private int GetRecommendationScore(LiveTvProgram program, Guid userId, Dictionary<string, Genre> genres)
2014-01-12 15:58:47 +00:00
{
var score = 0;
if (program.IsLive)
{
score++;
}
if (program.IsSeries && !program.IsRepeat)
{
score++;
}
2015-06-01 14:49:23 +00:00
var channel = GetInternalChannel(program.ChannelId);
2014-01-12 15:58:47 +00:00
var channelUserdata = _userDataManager.GetUserData(userId, channel.GetUserDataKey());
if ((channelUserdata.Likes ?? false))
{
score += 2;
}
else if (!(channelUserdata.Likes ?? true))
{
score -= 2;
}
if (channelUserdata.IsFavorite)
{
score += 3;
}
score += GetGenreScore(program.Genres, userId, genres);
return score;
}
private int GetGenreScore(IEnumerable<string> programGenres, Guid userId, Dictionary<string, Genre> genres)
{
return programGenres.Select(i =>
{
var score = 0;
Genre genre;
if (genres.TryGetValue(i, out genre))
{
var genreUserdata = _userDataManager.GetUserData(userId, genre.GetUserDataKey());
if ((genreUserdata.Likes ?? false))
{
score++;
}
else if (!(genreUserdata.Likes ?? true))
{
score--;
}
if (genreUserdata.IsFavorite)
{
score += 2;
}
}
return score;
}).Sum();
}
2015-11-22 23:06:11 +00:00
private async Task AddRecordingInfo(IEnumerable<Tuple<BaseItemDto, string, string>> programs, CancellationToken cancellationToken)
2013-12-21 18:37:34 +00:00
{
2015-03-19 16:16:33 +00:00
var timers = new Dictionary<string, List<TimerInfo>>();
2013-12-21 18:37:34 +00:00
2015-11-22 23:06:11 +00:00
foreach (var programTuple in programs)
2013-12-21 18:37:34 +00:00
{
2015-11-22 23:06:11 +00:00
var program = programTuple.Item1;
var serviceName = programTuple.Item2;
var externalProgramId = programTuple.Item3;
if (string.IsNullOrWhiteSpace(serviceName))
{
continue;
}
2015-05-31 19:12:58 +00:00
2015-03-19 16:16:33 +00:00
List<TimerInfo> timerList;
2015-11-22 23:06:11 +00:00
if (!timers.TryGetValue(serviceName, out timerList))
2015-03-19 16:16:33 +00:00
{
2015-04-17 04:53:47 +00:00
try
{
2015-11-22 23:06:11 +00:00
var tempTimers = await GetService(serviceName).GetTimersAsync(cancellationToken).ConfigureAwait(false);
timers[serviceName] = timerList = tempTimers.ToList();
2015-04-17 04:53:47 +00:00
}
catch (Exception ex)
{
_logger.ErrorException("Error getting timer infos", ex);
2015-11-22 23:06:11 +00:00
timers[serviceName] = timerList = new List<TimerInfo>();
2015-04-17 04:53:47 +00:00
}
2015-03-19 16:16:33 +00:00
}
2015-11-22 23:06:11 +00:00
var timer = timerList.FirstOrDefault(i => string.Equals(i.ProgramId, externalProgramId, StringComparison.OrdinalIgnoreCase));
2013-12-21 18:37:34 +00:00
if (timer != null)
{
2015-11-22 23:06:11 +00:00
program.TimerId = _tvDtoService.GetInternalTimerId(serviceName, timer.Id)
2013-12-21 18:37:34 +00:00
.ToString("N");
if (!string.IsNullOrEmpty(timer.SeriesTimerId))
{
2015-11-22 23:06:11 +00:00
program.SeriesTimerId = _tvDtoService.GetInternalSeriesTimerId(serviceName, timer.SeriesTimerId)
2013-12-21 18:37:34 +00:00
.ToString("N");
}
}
}
2013-11-25 21:53:06 +00:00
}
2015-06-01 14:49:23 +00:00
internal Task RefreshChannels(IProgress<double> progress, CancellationToken cancellationToken)
2014-02-27 16:25:04 +00:00
{
2015-06-01 14:49:23 +00:00
return RefreshChannelsInternal(progress, cancellationToken);
2014-02-27 16:25:04 +00:00
}
private async Task RefreshChannelsInternal(IProgress<double> progress, CancellationToken cancellationToken)
2013-11-25 21:53:06 +00:00
{
2015-03-19 16:16:33 +00:00
var numComplete = 0;
double progressPerService = _services.Count == 0
? 0
: 1 / _services.Count;
2013-11-25 21:53:06 +00:00
2015-06-01 14:49:23 +00:00
var newChannelIdList = new List<Guid>();
var newProgramIdList = new List<Guid>();
2015-03-19 16:16:33 +00:00
foreach (var service in _services)
{
2015-03-19 16:16:33 +00:00
cancellationToken.ThrowIfCancellationRequested();
_logger.Debug("Refreshing guide from {0}", service.Name);
2015-03-19 16:16:33 +00:00
try
{
var innerProgress = new ActionableProgress<double>();
innerProgress.RegisterAction(p => progress.Report(p * progressPerService));
2015-06-01 14:49:23 +00:00
var idList = await RefreshChannelsInternal(service, innerProgress, cancellationToken).ConfigureAwait(false);
newChannelIdList.AddRange(idList.Item1);
newProgramIdList.AddRange(idList.Item2);
2015-03-19 16:16:33 +00:00
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception ex)
{
_logger.ErrorException("Error refreshing channels for service", ex);
}
numComplete++;
double percent = numComplete;
percent /= _services.Count;
progress.Report(100 * percent);
}
2013-11-25 21:53:06 +00:00
2015-06-01 17:07:55 +00:00
await CleanDatabaseInternal(newChannelIdList, new[] { typeof(LiveTvChannel).Name }, progress, cancellationToken).ConfigureAwait(false);
await CleanDatabaseInternal(newProgramIdList, new[] { typeof(LiveTvProgram).Name }, progress, cancellationToken).ConfigureAwait(false);
2015-06-01 14:49:23 +00:00
2015-09-18 01:51:22 +00:00
var coreService = _services.OfType<EmbyTV.EmbyTV>().FirstOrDefault();
if (coreService != null)
{
await coreService.RefreshSeriesTimers(cancellationToken, new Progress<double>()).ConfigureAwait(false);
}
2015-06-01 14:49:23 +00:00
// Load these now which will prefetch metadata
var dtoOptions = new DtoOptions();
dtoOptions.Fields.Remove(ItemFields.SyncInfo);
await GetRecordings(new RecordingQuery(), dtoOptions, cancellationToken).ConfigureAwait(false);
2015-03-19 16:16:33 +00:00
progress.Report(100);
}
2015-06-01 17:07:55 +00:00
private async Task<Tuple<List<Guid>, List<Guid>>> RefreshChannelsInternal(ILiveTvService service, IProgress<double> progress, CancellationToken cancellationToken)
2015-03-19 16:16:33 +00:00
{
2013-11-25 21:53:06 +00:00
progress.Report(10);
var allChannels = await GetChannels(service, cancellationToken).ConfigureAwait(false);
var allChannelsList = allChannels.ToList();
2013-11-25 21:53:06 +00:00
2013-12-19 21:51:32 +00:00
var list = new List<LiveTvChannel>();
2013-11-25 21:53:06 +00:00
var numComplete = 0;
2015-11-22 23:06:11 +00:00
var parentFolder = await GetInternalLiveTvFolder(cancellationToken).ConfigureAwait(false);
var parentFolderId = parentFolder.Id;
2013-11-25 21:53:06 +00:00
foreach (var channelInfo in allChannelsList)
2013-11-25 21:53:06 +00:00
{
2014-02-09 21:11:11 +00:00
cancellationToken.ThrowIfCancellationRequested();
2013-11-25 21:53:06 +00:00
try
{
2015-11-22 23:06:11 +00:00
var item = await GetChannel(channelInfo.Item2, channelInfo.Item1, parentFolderId, cancellationToken).ConfigureAwait(false);
2013-11-25 21:53:06 +00:00
2014-01-03 04:58:22 +00:00
list.Add(item);
2014-01-11 05:49:18 +00:00
_libraryManager.RegisterItem(item);
2014-01-03 04:58:22 +00:00
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception ex)
{
_logger.ErrorException("Error getting channel information for {0}", ex, channelInfo.Item2.Name);
}
numComplete++;
double percent = numComplete;
percent /= allChannelsList.Count;
progress.Report(5 * percent + 10);
}
2014-01-11 05:49:18 +00:00
2014-01-03 04:58:22 +00:00
progress.Report(15);
2014-01-11 23:07:56 +00:00
numComplete = 0;
2015-06-01 14:49:23 +00:00
var programs = new List<Guid>();
var channels = new List<Guid>();
2014-01-03 04:58:22 +00:00
2014-01-12 16:55:38 +00:00
var guideDays = GetGuideDays(list.Count);
2015-11-22 23:06:11 +00:00
_logger.Info("Refreshing guide with {0} days of guide data", guideDays);
2014-02-09 21:11:11 +00:00
cancellationToken.ThrowIfCancellationRequested();
2015-06-01 14:49:23 +00:00
foreach (var currentChannel in list)
2014-01-03 04:58:22 +00:00
{
2015-06-01 14:49:23 +00:00
channels.Add(currentChannel.Id);
2014-02-09 21:11:11 +00:00
cancellationToken.ThrowIfCancellationRequested();
2014-01-03 04:58:22 +00:00
try
{
2014-01-12 16:55:38 +00:00
var start = DateTime.UtcNow.AddHours(-1);
var end = start.AddDays(guideDays);
2014-01-12 15:58:47 +00:00
2014-01-23 18:05:41 +00:00
var channelPrograms = await service.GetProgramsAsync(currentChannel.ExternalId, start, end, cancellationToken).ConfigureAwait(false);
2013-11-25 21:53:06 +00:00
2015-03-16 01:48:25 +00:00
foreach (var program in channelPrograms)
{
2015-11-22 23:06:11 +00:00
var programItem = await GetProgram(program, currentChannel, currentChannel.ChannelType, service.Name, cancellationToken).ConfigureAwait(false);
2015-09-21 16:26:05 +00:00
2015-06-01 14:49:23 +00:00
programs.Add(programItem.Id);
2015-03-16 01:48:25 +00:00
}
2013-11-25 21:53:06 +00:00
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception ex)
{
2014-01-03 04:58:22 +00:00
_logger.ErrorException("Error getting programs for channel {0}", ex, currentChannel.Name);
2013-11-25 21:53:06 +00:00
}
numComplete++;
double percent = numComplete;
percent /= allChannelsList.Count;
2013-11-25 21:53:06 +00:00
2014-02-27 16:25:04 +00:00
progress.Report(80 * percent + 10);
2013-11-25 21:53:06 +00:00
}
2014-02-27 16:25:04 +00:00
progress.Report(100);
2015-06-01 17:07:55 +00:00
return new Tuple<List<Guid>, List<Guid>>(channels, programs);
2015-02-10 19:47:54 +00:00
}
2015-06-01 17:07:55 +00:00
private async Task CleanDatabaseInternal(List<Guid> currentIdList, string[] validTypes, IProgress<double> progress, CancellationToken cancellationToken)
{
2015-06-01 14:49:23 +00:00
var list = _itemRepo.GetItemIds(new InternalItemsQuery
{
2015-06-01 17:07:55 +00:00
IncludeItemTypes = validTypes
2015-06-01 14:49:23 +00:00
}).Items.ToList();
var numComplete = 0;
2015-06-01 14:49:23 +00:00
foreach (var itemId in list)
{
cancellationToken.ThrowIfCancellationRequested();
if (itemId == Guid.Empty)
{
// Somehow some invalid data got into the db. It probably predates the boundary checking
continue;
}
2015-06-01 14:49:23 +00:00
if (!currentIdList.Contains(itemId))
{
2015-06-01 14:49:23 +00:00
var item = _libraryManager.GetItemById(itemId);
2015-03-21 16:10:02 +00:00
2015-06-01 14:49:23 +00:00
if (item != null)
2015-03-21 16:10:02 +00:00
{
2015-06-02 05:46:06 +00:00
await _libraryManager.DeleteItem(item, new DeleteOptions
{
DeleteFileLocation = false
}).ConfigureAwait(false);
2015-03-21 16:10:02 +00:00
}
}
numComplete++;
double percent = numComplete;
percent /= list.Count;
2014-02-27 16:25:04 +00:00
progress.Report(100 * percent);
}
}
2015-11-22 23:06:11 +00:00
private const int MaxGuideDays = 14;
2014-01-12 16:55:38 +00:00
private double GetGuideDays(int channelCount)
{
2014-07-27 22:01:29 +00:00
var config = GetConfiguration();
if (config.GuideDays.HasValue)
2014-01-12 16:55:38 +00:00
{
2015-11-22 23:06:11 +00:00
return Math.Max(1, Math.Min(config.GuideDays.Value, MaxGuideDays));
2014-01-12 16:55:38 +00:00
}
var programsPerDay = channelCount * 48;
2014-01-17 03:13:12 +00:00
const int maxPrograms = 24000;
2014-01-12 16:55:38 +00:00
var days = Math.Round(((double)maxPrograms) / programsPerDay);
2015-11-22 23:06:11 +00:00
return Math.Max(3, Math.Min(days, MaxGuideDays));
2014-01-12 16:55:38 +00:00
}
2013-11-26 21:36:11 +00:00
private async Task<IEnumerable<Tuple<string, ChannelInfo>>> GetChannels(ILiveTvService service, CancellationToken cancellationToken)
2013-11-25 21:53:06 +00:00
{
2013-11-26 21:36:11 +00:00
var channels = await service.GetChannelsAsync(cancellationToken).ConfigureAwait(false);
2013-11-25 21:53:06 +00:00
2013-11-26 21:36:11 +00:00
return channels.Select(i => new Tuple<string, ChannelInfo>(service.Name, i));
2013-11-25 21:53:06 +00:00
}
2015-06-01 17:07:55 +00:00
private DateTime _lastRecordingRefreshTime;
private async Task RefreshRecordings(CancellationToken cancellationToken)
2013-11-26 02:53:48 +00:00
{
2015-06-01 17:07:55 +00:00
const int cacheMinutes = 5;
if ((DateTime.UtcNow - _lastRecordingRefreshTime).TotalMinutes < cacheMinutes)
2014-06-23 16:05:19 +00:00
{
2015-06-01 17:07:55 +00:00
return;
}
await _refreshRecordingsLock.WaitAsync(cancellationToken).ConfigureAwait(false);
try
{
if ((DateTime.UtcNow - _lastRecordingRefreshTime).TotalMinutes < cacheMinutes)
2014-06-23 16:05:19 +00:00
{
2015-06-01 17:07:55 +00:00
return;
}
2015-06-01 17:07:55 +00:00
var tasks = _services.Select(async i =>
{
2015-06-01 17:07:55 +00:00
try
{
var recs = await i.GetRecordingsAsync(cancellationToken).ConfigureAwait(false);
return recs.Select(r => new Tuple<RecordingInfo, ILiveTvService>(r, i));
}
catch (Exception ex)
{
_logger.ErrorException("Error getting recordings", ex);
return new List<Tuple<RecordingInfo, ILiveTvService>>();
}
});
2014-06-23 16:05:19 +00:00
2015-06-01 17:07:55 +00:00
var results = await Task.WhenAll(tasks).ConfigureAwait(false);
2015-11-22 23:06:11 +00:00
var folder = await GetInternalLiveTvFolder(cancellationToken).ConfigureAwait(false);
var parentFolderId = folder.Id;
2015-06-01 17:07:55 +00:00
2015-11-22 23:06:11 +00:00
var recordingTasks = results.SelectMany(i => i.ToList()).Select(i => CreateRecordingRecord(i.Item1, i.Item2.Name, parentFolderId, cancellationToken));
2015-06-01 17:07:55 +00:00
var idList = await Task.WhenAll(recordingTasks).ConfigureAwait(false);
2015-10-11 00:39:30 +00:00
await CleanDatabaseInternal(idList.ToList(), new[] { typeof(LiveTvVideoRecording).Name, typeof(LiveTvAudioRecording).Name }, new Progress<double>(), cancellationToken).ConfigureAwait(false);
2013-11-26 21:36:11 +00:00
2015-06-01 17:07:55 +00:00
_lastRecordingRefreshTime = DateTime.UtcNow;
}
finally
{
_refreshRecordingsLock.Release();
}
}
public async Task<QueryResult<BaseItem>> GetInternalRecordings(RecordingQuery query, CancellationToken cancellationToken)
{
var user = string.IsNullOrEmpty(query.UserId) ? null : _userManager.GetUserById(query.UserId);
2014-06-23 16:05:19 +00:00
if (user != null && !IsLiveTvEnabled(user))
{
2015-06-01 17:07:55 +00:00
return new QueryResult<BaseItem>();
2014-06-23 16:05:19 +00:00
}
2015-06-01 17:07:55 +00:00
await RefreshRecordings(cancellationToken).ConfigureAwait(false);
var internalQuery = new InternalItemsQuery
2013-12-19 21:51:32 +00:00
{
2015-06-01 17:07:55 +00:00
IncludeItemTypes = new[] { typeof(LiveTvVideoRecording).Name, typeof(LiveTvAudioRecording).Name }
};
2013-12-28 21:37:01 +00:00
2015-06-01 17:07:55 +00:00
if (!string.IsNullOrEmpty(query.ChannelId))
{
internalQuery.ChannelIds = new[] { query.ChannelId };
2013-11-26 21:36:11 +00:00
}
2015-06-01 17:07:55 +00:00
var queryResult = _libraryManager.GetItems(internalQuery);
IEnumerable<ILiveTvRecording> recordings = queryResult.Items.Cast<ILiveTvRecording>();
2013-12-19 21:51:32 +00:00
if (!string.IsNullOrEmpty(query.Id))
2013-11-26 21:36:11 +00:00
{
2013-12-28 21:37:01 +00:00
var guid = new Guid(query.Id);
recordings = recordings
2015-06-01 17:07:55 +00:00
.Where(i => i.Id == guid);
2013-12-28 21:37:01 +00:00
}
if (!string.IsNullOrEmpty(query.GroupId))
{
var guid = new Guid(query.GroupId);
2015-06-01 17:07:55 +00:00
recordings = recordings.Where(i => GetRecordingGroupIds(i).Contains(guid));
}
if (query.IsInProgress.HasValue)
{
var val = query.IsInProgress.Value;
2015-06-01 17:07:55 +00:00
recordings = recordings.Where(i => (i.Status == RecordingStatus.InProgress) == val);
2013-11-26 21:36:11 +00:00
}
if (query.Status.HasValue)
{
var val = query.Status.Value;
2015-06-01 17:07:55 +00:00
recordings = recordings.Where(i => (i.Status == val));
}
2014-01-08 05:25:21 +00:00
if (!string.IsNullOrEmpty(query.SeriesTimerId))
{
var guid = new Guid(query.SeriesTimerId);
recordings = recordings
2015-06-01 17:07:55 +00:00
.Where(i => _tvDtoService.GetInternalSeriesTimerId(i.ServiceName, i.SeriesTimerId) == guid);
2014-01-08 05:25:21 +00:00
}
2015-06-01 17:07:55 +00:00
recordings = recordings.OrderByDescending(i => i.StartDate);
var entityList = recordings.ToList();
IEnumerable<ILiveTvRecording> entities = entityList;
2014-03-13 09:00:47 +00:00
2013-12-28 23:09:24 +00:00
if (query.StartIndex.HasValue)
{
entities = entities.Skip(query.StartIndex.Value);
}
if (query.Limit.HasValue)
{
entities = entities.Take(query.Limit.Value);
2013-12-21 18:37:34 +00:00
}
2014-08-14 13:24:30 +00:00
return new QueryResult<BaseItem>
{
Items = entities.Cast<BaseItem>().ToArray(),
TotalRecordCount = entityList.Count
};
}
2015-10-11 16:12:53 +00:00
public void AddInfoToProgramDto(BaseItem item, BaseItemDto dto, bool addChannelInfo, User user = null)
2015-05-31 19:12:58 +00:00
{
var program = (LiveTvProgram)item;
dto.StartDate = program.StartDate;
dto.EpisodeTitle = program.EpisodeTitle;
2015-08-06 01:21:18 +00:00
2015-10-11 16:12:53 +00:00
if (program.IsRepeat)
{
dto.IsRepeat = program.IsRepeat;
}
2015-08-06 01:21:18 +00:00
if (program.IsMovie)
{
dto.IsMovie = program.IsMovie;
}
if (program.IsSeries)
{
dto.IsSeries = program.IsSeries;
}
if (program.IsSports)
{
dto.IsSports = program.IsSports;
}
if (program.IsLive)
{
dto.IsLive = program.IsLive;
}
if (program.IsNews)
{
dto.IsNews = program.IsNews;
}
if (program.IsKids)
{
dto.IsKids = program.IsKids;
}
if (program.IsPremiere)
{
dto.IsPremiere = program.IsPremiere;
}
2015-10-11 16:12:53 +00:00
if (addChannelInfo)
2015-05-31 19:12:58 +00:00
{
2015-10-11 16:12:53 +00:00
var channel = GetInternalChannel(program.ChannelId);
2015-05-31 19:12:58 +00:00
2015-10-11 16:12:53 +00:00
if (channel != null)
2015-05-31 19:12:58 +00:00
{
2015-10-11 16:12:53 +00:00
dto.ChannelName = channel.Name;
2015-10-16 17:06:31 +00:00
if (channel.HasImage(ImageType.Primary))
2015-10-11 16:12:53 +00:00
{
dto.ChannelPrimaryImageTag = _tvDtoService.GetImageTag(channel);
}
2015-05-31 19:12:58 +00:00
}
}
}
2015-05-31 18:22:51 +00:00
public void AddInfoToRecordingDto(BaseItem item, BaseItemDto dto, User user = null)
2014-08-14 13:24:30 +00:00
{
2015-05-31 18:22:51 +00:00
var recording = (ILiveTvRecording)item;
var service = GetService(recording);
2014-08-14 13:24:30 +00:00
2015-06-01 17:07:55 +00:00
var channel = string.IsNullOrWhiteSpace(recording.ChannelId) ? null : GetInternalChannel(recording.ChannelId);
2014-08-14 13:24:30 +00:00
2015-06-01 17:07:55 +00:00
var info = recording;
2015-05-31 18:22:51 +00:00
dto.SeriesTimerId = string.IsNullOrEmpty(info.SeriesTimerId)
? null
: _tvDtoService.GetInternalSeriesTimerId(service.Name, info.SeriesTimerId).ToString("N");
dto.StartDate = info.StartDate;
dto.RecordingStatus = info.Status;
dto.IsRepeat = info.IsRepeat;
dto.EpisodeTitle = info.EpisodeTitle;
dto.IsMovie = info.IsMovie;
dto.IsSeries = info.IsSeries;
dto.IsSports = info.IsSports;
dto.IsLive = info.IsLive;
dto.IsNews = info.IsNews;
dto.IsKids = info.IsKids;
dto.IsPremiere = info.IsPremiere;
dto.CanDelete = user == null
? recording.CanDelete()
: recording.CanDelete(user);
if (dto.MediaSources == null)
{
dto.MediaSources = recording.GetMediaSources(true).ToList();
}
if (dto.MediaStreams == null)
{
dto.MediaStreams = dto.MediaSources.SelectMany(i => i.MediaStreams).ToList();
}
2015-06-01 17:07:55 +00:00
if (info.Status == RecordingStatus.InProgress && info.EndDate.HasValue)
2015-05-31 18:22:51 +00:00
{
var now = DateTime.UtcNow.Ticks;
var start = info.StartDate.Ticks;
2015-06-01 17:07:55 +00:00
var end = info.EndDate.Value.Ticks;
2015-05-31 18:22:51 +00:00
var pct = now - start;
pct /= end;
pct *= 100;
dto.CompletionPercentage = pct;
}
if (channel != null)
{
dto.ChannelName = channel.Name;
2015-10-16 17:06:31 +00:00
if (channel.HasImage(ImageType.Primary))
2013-12-23 03:46:03 +00:00
{
2015-05-31 18:22:51 +00:00
dto.ChannelPrimaryImageTag = _tvDtoService.GetImageTag(channel);
}
}
}
2015-03-19 16:16:33 +00:00
2015-05-31 18:22:51 +00:00
public async Task<QueryResult<BaseItemDto>> GetRecordings(RecordingQuery query, DtoOptions options, CancellationToken cancellationToken)
{
var user = string.IsNullOrEmpty(query.UserId) ? null : _userManager.GetUserById(query.UserId);
var internalResult = await GetInternalRecordings(query, cancellationToken).ConfigureAwait(false);
var returnArray = internalResult.Items
.Select(i => _dtoService.GetBaseItemDto(i, options, user))
2013-11-27 19:04:19 +00:00
.ToArray();
2013-11-26 02:53:48 +00:00
2015-04-12 18:58:21 +00:00
if (user != null)
{
_dtoService.FillSyncInfo(returnArray, new DtoOptions(), user);
}
2015-05-31 18:22:51 +00:00
return new QueryResult<BaseItemDto>
2013-11-26 02:53:48 +00:00
{
Items = returnArray,
2014-08-14 13:24:30 +00:00
TotalRecordCount = internalResult.TotalRecordCount
2013-11-26 02:53:48 +00:00
};
}
2013-11-26 21:36:11 +00:00
2013-11-27 19:04:19 +00:00
public async Task<QueryResult<TimerInfoDto>> GetTimers(TimerQuery query, CancellationToken cancellationToken)
{
2015-03-22 23:55:33 +00:00
var tasks = _services.Select(async i =>
{
try
{
var recs = await i.GetTimersAsync(cancellationToken).ConfigureAwait(false);
return recs.Select(r => new Tuple<TimerInfo, ILiveTvService>(r, i));
}
catch (Exception ex)
{
_logger.ErrorException("Error getting recordings", ex);
return new List<Tuple<TimerInfo, ILiveTvService>>();
}
});
var results = await Task.WhenAll(tasks).ConfigureAwait(false);
var timers = results.SelectMany(i => i.ToList());
2013-11-27 19:04:19 +00:00
if (!string.IsNullOrEmpty(query.ChannelId))
{
2013-12-22 17:16:24 +00:00
var guid = new Guid(query.ChannelId);
2015-03-22 23:55:33 +00:00
timers = timers.Where(i => guid == _tvDtoService.GetInternalChannelId(i.Item2.Name, i.Item1.ChannelId));
2013-11-27 19:04:19 +00:00
}
2014-01-08 05:25:21 +00:00
if (!string.IsNullOrEmpty(query.SeriesTimerId))
{
var guid = new Guid(query.SeriesTimerId);
timers = timers
2015-03-22 23:55:33 +00:00
.Where(i => _tvDtoService.GetInternalSeriesTimerId(i.Item2.Name, i.Item1.SeriesTimerId) == guid);
2014-01-08 05:25:21 +00:00
}
var returnList = new List<TimerInfoDto>();
2013-12-22 17:16:24 +00:00
foreach (var i in timers)
{
2015-03-22 23:55:33 +00:00
var program = string.IsNullOrEmpty(i.Item1.ProgramId) ?
null :
2015-03-22 23:55:33 +00:00
GetInternalProgram(_tvDtoService.GetInternalProgramId(i.Item2.Name, i.Item1.ProgramId).ToString("N"));
2015-03-22 23:55:33 +00:00
var channel = string.IsNullOrEmpty(i.Item1.ChannelId) ? null : GetInternalChannel(_tvDtoService.GetInternalChannelId(i.Item2.Name, i.Item1.ChannelId));
2015-03-22 23:55:33 +00:00
returnList.Add(_tvDtoService.GetTimerInfoDto(i.Item1, i.Item2, program, channel));
}
var returnArray = returnList
2013-12-22 17:16:24 +00:00
.OrderBy(i => i.StartDate)
2013-11-27 19:04:19 +00:00
.ToArray();
return new QueryResult<TimerInfoDto>
{
Items = returnArray,
TotalRecordCount = returnArray.Length
};
}
public async Task DeleteRecording(string recordingId)
{
2015-05-31 18:22:51 +00:00
var recording = await GetInternalRecording(recordingId, CancellationToken.None).ConfigureAwait(false);
if (recording == null)
{
throw new ResourceNotFoundException(string.Format("Recording with Id {0} not found", recordingId));
}
2015-03-12 15:51:48 +00:00
var service = GetService(recording.ServiceName);
2015-10-11 00:39:30 +00:00
try
{
await service.DeleteRecordingAsync(recording.ExternalId, CancellationToken.None).ConfigureAwait(false);
}
catch (ResourceNotFoundException)
{
2015-10-16 22:36:01 +00:00
2015-10-11 00:39:30 +00:00
}
2015-11-06 15:00:55 +00:00
// This is the responsibility of the live tv service
await _libraryManager.DeleteItem((BaseItem)recording, new DeleteOptions
{
DeleteFileLocation = false
}).ConfigureAwait(false);
2015-10-11 00:39:30 +00:00
2015-06-01 17:07:55 +00:00
_lastRecordingRefreshTime = DateTime.MinValue;
}
public async Task CancelTimer(string id)
{
2013-12-15 14:19:24 +00:00
var timer = await GetTimer(id, CancellationToken.None).ConfigureAwait(false);
if (timer == null)
{
2013-12-15 14:19:24 +00:00
throw new ResourceNotFoundException(string.Format("Timer with Id {0} not found", id));
}
2015-03-12 15:51:48 +00:00
var service = GetService(timer.ServiceName);
2013-12-15 14:19:24 +00:00
await service.CancelTimerAsync(timer.ExternalId, CancellationToken.None).ConfigureAwait(false);
2015-06-01 17:07:55 +00:00
_lastRecordingRefreshTime = DateTime.MinValue;
2013-12-15 14:19:24 +00:00
}
2013-12-15 14:19:24 +00:00
public async Task CancelSeriesTimer(string id)
{
var timer = await GetSeriesTimer(id, CancellationToken.None).ConfigureAwait(false);
if (timer == null)
{
throw new ResourceNotFoundException(string.Format("Timer with Id {0} not found", id));
}
2015-03-12 15:51:48 +00:00
var service = GetService(timer.ServiceName);
2013-12-15 14:19:24 +00:00
await service.CancelSeriesTimerAsync(timer.ExternalId, CancellationToken.None).ConfigureAwait(false);
2015-06-01 17:07:55 +00:00
_lastRecordingRefreshTime = DateTime.MinValue;
}
2015-05-31 18:22:51 +00:00
public async Task<BaseItemDto> GetRecording(string id, DtoOptions options, CancellationToken cancellationToken, User user = null)
{
2015-05-31 18:22:51 +00:00
var item = await GetInternalRecording(id, cancellationToken).ConfigureAwait(false);
2013-12-15 01:17:57 +00:00
2015-05-31 18:22:51 +00:00
if (item == null)
{
return null;
}
2015-05-31 18:22:51 +00:00
return _dtoService.GetBaseItemDto((BaseItem)item, options, user);
}
public async Task<TimerInfoDto> GetTimer(string id, CancellationToken cancellationToken)
{
var results = await GetTimers(new TimerQuery(), cancellationToken).ConfigureAwait(false);
2014-11-14 06:27:10 +00:00
return results.Items.FirstOrDefault(i => string.Equals(i.Id, id, StringComparison.OrdinalIgnoreCase));
}
2013-12-15 01:17:57 +00:00
public async Task<SeriesTimerInfoDto> GetSeriesTimer(string id, CancellationToken cancellationToken)
{
var results = await GetSeriesTimers(new SeriesTimerQuery(), cancellationToken).ConfigureAwait(false);
2014-11-14 06:27:10 +00:00
return results.Items.FirstOrDefault(i => string.Equals(i.Id, id, StringComparison.OrdinalIgnoreCase));
2013-12-15 01:17:57 +00:00
}
2013-12-15 14:19:24 +00:00
2013-12-15 01:17:57 +00:00
public async Task<QueryResult<SeriesTimerInfoDto>> GetSeriesTimers(SeriesTimerQuery query, CancellationToken cancellationToken)
{
2015-03-22 23:55:33 +00:00
var tasks = _services.Select(async i =>
{
try
{
var recs = await i.GetSeriesTimersAsync(cancellationToken).ConfigureAwait(false);
return recs.Select(r => new Tuple<SeriesTimerInfo, ILiveTvService>(r, i));
}
catch (Exception ex)
{
_logger.ErrorException("Error getting recordings", ex);
return new List<Tuple<SeriesTimerInfo, ILiveTvService>>();
}
});
var results = await Task.WhenAll(tasks).ConfigureAwait(false);
var timers = results.SelectMany(i => i.ToList());
2013-12-15 01:17:57 +00:00
2014-01-11 23:07:56 +00:00
if (string.Equals(query.SortBy, "Priority", StringComparison.OrdinalIgnoreCase))
{
timers = query.SortOrder == SortOrder.Descending ?
2015-03-22 23:55:33 +00:00
timers.OrderBy(i => i.Item1.Priority).ThenByStringDescending(i => i.Item1.Name) :
timers.OrderByDescending(i => i.Item1.Priority).ThenByString(i => i.Item1.Name);
2014-01-11 23:07:56 +00:00
}
else
{
timers = query.SortOrder == SortOrder.Descending ?
2015-03-22 23:55:33 +00:00
timers.OrderByStringDescending(i => i.Item1.Name) :
timers.OrderByString(i => i.Item1.Name);
2014-01-11 23:07:56 +00:00
}
2013-12-22 18:58:51 +00:00
var returnArray = timers
2013-12-23 03:46:03 +00:00
.Select(i =>
{
string channelName = null;
2015-03-22 23:55:33 +00:00
if (!string.IsNullOrEmpty(i.Item1.ChannelId))
2013-12-23 03:46:03 +00:00
{
2015-03-22 23:55:33 +00:00
var internalChannelId = _tvDtoService.GetInternalChannelId(i.Item2.Name, i.Item1.ChannelId);
2013-12-28 16:58:13 +00:00
var channel = GetInternalChannel(internalChannelId);
2014-01-23 18:05:41 +00:00
channelName = channel == null ? null : channel.Name;
2013-12-23 03:46:03 +00:00
}
2015-03-22 23:55:33 +00:00
return _tvDtoService.GetSeriesTimerInfoDto(i.Item1, i.Item2, channelName);
2013-12-23 03:46:03 +00:00
})
2013-12-15 01:17:57 +00:00
.ToArray();
return new QueryResult<SeriesTimerInfoDto>
{
Items = returnArray,
TotalRecordCount = returnArray.Length
};
}
public async Task<ChannelInfoDto> GetChannel(string id, CancellationToken cancellationToken, User user = null)
2013-12-15 01:17:57 +00:00
{
2013-12-22 17:16:24 +00:00
var channel = GetInternalChannel(id);
2013-12-15 01:17:57 +00:00
2015-06-01 14:49:23 +00:00
var now = DateTime.UtcNow;
2013-12-15 01:17:57 +00:00
2015-06-01 14:49:23 +00:00
var programs = _libraryManager.GetItems(new InternalItemsQuery
{
IncludeItemTypes = new[] { typeof(LiveTvProgram).Name },
ChannelIds = new[] { id },
MaxStartDate = now,
MinEndDate = now,
2015-11-22 23:06:11 +00:00
Limit = 1,
SortBy = new[] { "StartDate" }
2013-12-17 20:02:12 +00:00
2015-06-01 14:49:23 +00:00
}).Items.Cast<LiveTvProgram>();
2014-01-02 21:21:06 +00:00
2015-11-22 23:06:11 +00:00
var currentProgram = programs.FirstOrDefault();
2015-08-02 17:02:23 +00:00
var dto = _tvDtoService.GetChannelInfoDto(channel, new DtoOptions(), currentProgram, user);
2015-06-01 14:49:23 +00:00
return dto;
2014-01-02 21:21:06 +00:00
}
public void AddChannelInfo(BaseItemDto dto, LiveTvChannel channel, DtoOptions options, User user)
{
dto.MediaSources = channel.GetMediaSources(true).ToList();
var now = DateTime.UtcNow;
var programs = _libraryManager.GetItems(new InternalItemsQuery
{
IncludeItemTypes = new[] { typeof(LiveTvProgram).Name },
ChannelIds = new[] { channel.Id.ToString("N") },
MaxStartDate = now,
MinEndDate = now,
2015-11-22 23:06:11 +00:00
Limit = 1,
SortBy = new[] { "StartDate" }
}).Items.Cast<LiveTvProgram>();
2015-11-22 23:06:11 +00:00
var currentProgram = programs.FirstOrDefault();
if (currentProgram != null)
{
dto.CurrentProgram = _dtoService.GetBaseItemDto(currentProgram, options, user);
}
}
2015-03-20 05:40:51 +00:00
private async Task<Tuple<SeriesTimerInfo, ILiveTvService>> GetNewTimerDefaultsInternal(CancellationToken cancellationToken, LiveTvProgram program = null)
2013-12-17 20:02:12 +00:00
{
2015-03-19 16:16:33 +00:00
var service = program != null && !string.IsNullOrWhiteSpace(program.ServiceName) ?
GetService(program) :
_services.FirstOrDefault();
2014-01-23 18:05:41 +00:00
ProgramInfo programInfo = null;
if (program != null)
{
2015-06-01 14:49:23 +00:00
var channel = GetInternalChannel(program.ChannelId);
2014-01-23 18:05:41 +00:00
programInfo = new ProgramInfo
{
Audio = program.Audio,
2015-06-01 14:49:23 +00:00
ChannelId = channel.ExternalId,
2014-01-23 18:05:41 +00:00
CommunityRating = program.CommunityRating,
EndDate = program.EndDate ?? DateTime.MinValue,
EpisodeTitle = program.EpisodeTitle,
Genres = program.Genres,
Id = program.ExternalId,
IsHD = program.IsHD,
IsKids = program.IsKids,
IsLive = program.IsLive,
IsMovie = program.IsMovie,
IsNews = program.IsNews,
IsPremiere = program.IsPremiere,
IsRepeat = program.IsRepeat,
IsSeries = program.IsSeries,
IsSports = program.IsSports,
OriginalAirDate = program.PremiereDate,
Overview = program.Overview,
StartDate = program.StartDate,
2015-10-25 17:13:30 +00:00
//ImagePath = program.ExternalImagePath,
2014-01-23 18:05:41 +00:00
Name = program.Name,
2015-08-16 22:03:22 +00:00
OfficialRating = program.OfficialRating
2014-01-23 18:05:41 +00:00
};
}
2015-03-19 16:16:33 +00:00
var info = await service.GetNewTimerDefaultsAsync(cancellationToken, programInfo).ConfigureAwait(false);
2013-12-22 18:58:51 +00:00
info.Id = null;
2013-12-17 20:02:12 +00:00
2015-03-19 16:16:33 +00:00
return new Tuple<SeriesTimerInfo, ILiveTvService>(info, service);
}
public async Task<SeriesTimerInfoDto> GetNewTimerDefaults(CancellationToken cancellationToken)
{
var info = await GetNewTimerDefaultsInternal(cancellationToken).ConfigureAwait(false);
2013-12-18 05:44:46 +00:00
2015-03-19 16:16:33 +00:00
var obj = _tvDtoService.GetSeriesTimerInfoDto(info.Item1, info.Item2, null);
2013-12-18 05:44:46 +00:00
return obj;
}
public async Task<SeriesTimerInfoDto> GetNewTimerDefaults(string programId, CancellationToken cancellationToken)
{
2015-03-14 20:00:32 +00:00
var program = GetInternalProgram(programId);
var programDto = await GetProgram(programId, cancellationToken).ConfigureAwait(false);
2013-12-18 05:44:46 +00:00
var defaults = await GetNewTimerDefaultsInternal(cancellationToken, program).ConfigureAwait(false);
2015-03-19 16:16:33 +00:00
var info = _tvDtoService.GetSeriesTimerInfoDto(defaults.Item1, defaults.Item2, null);
2013-12-18 05:44:46 +00:00
info.Days = new List<DayOfWeek>
{
program.StartDate.ToLocalTime().DayOfWeek
};
info.DayPattern = _tvDtoService.GetDayPattern(info.Days);
info.Name = program.Name;
2014-01-14 20:03:35 +00:00
info.ChannelId = programDto.ChannelId;
info.ChannelName = programDto.ChannelName;
2013-12-18 05:44:46 +00:00
info.StartDate = program.StartDate;
info.Name = program.Name;
info.Overview = program.Overview;
2014-01-14 20:03:35 +00:00
info.ProgramId = programDto.Id;
2015-05-31 19:12:58 +00:00
info.ExternalProgramId = program.ExternalId;
2013-12-18 05:44:46 +00:00
2014-01-23 18:05:41 +00:00
if (program.EndDate.HasValue)
{
info.EndDate = program.EndDate.Value;
}
2013-12-18 05:44:46 +00:00
return info;
2013-12-17 20:02:12 +00:00
}
public async Task CreateTimer(TimerInfoDto timer, CancellationToken cancellationToken)
{
2015-03-12 15:51:48 +00:00
var service = GetService(timer.ServiceName);
2013-12-17 20:02:12 +00:00
var info = await _tvDtoService.GetTimerInfo(timer, true, this, cancellationToken).ConfigureAwait(false);
2013-12-18 05:44:46 +00:00
// Set priority from default values
var defaultValues = await service.GetNewTimerDefaultsAsync(cancellationToken).ConfigureAwait(false);
info.Priority = defaultValues.Priority;
2013-12-17 20:02:12 +00:00
await service.CreateTimerAsync(info, cancellationToken).ConfigureAwait(false);
2015-06-01 17:07:55 +00:00
_lastRecordingRefreshTime = DateTime.MinValue;
2016-01-21 17:45:42 +00:00
_logger.Info("New recording scheduled");
2013-12-17 20:02:12 +00:00
}
public async Task CreateSeriesTimer(SeriesTimerInfoDto timer, CancellationToken cancellationToken)
{
2015-03-12 15:51:48 +00:00
var service = GetService(timer.ServiceName);
2013-12-17 20:02:12 +00:00
var info = await _tvDtoService.GetSeriesTimerInfo(timer, true, this, cancellationToken).ConfigureAwait(false);
2013-12-18 05:44:46 +00:00
// Set priority from default values
var defaultValues = await service.GetNewTimerDefaultsAsync(cancellationToken).ConfigureAwait(false);
info.Priority = defaultValues.Priority;
2013-12-17 20:02:12 +00:00
await service.CreateSeriesTimerAsync(info, cancellationToken).ConfigureAwait(false);
2015-06-01 17:07:55 +00:00
_lastRecordingRefreshTime = DateTime.MinValue;
2013-12-17 20:02:12 +00:00
}
public async Task UpdateTimer(TimerInfoDto timer, CancellationToken cancellationToken)
{
var info = await _tvDtoService.GetTimerInfo(timer, false, this, cancellationToken).ConfigureAwait(false);
2015-03-12 15:51:48 +00:00
var service = GetService(timer.ServiceName);
2013-12-17 20:02:12 +00:00
await service.UpdateTimerAsync(info, cancellationToken).ConfigureAwait(false);
2015-06-01 17:07:55 +00:00
_lastRecordingRefreshTime = DateTime.MinValue;
2013-12-17 20:02:12 +00:00
}
public async Task UpdateSeriesTimer(SeriesTimerInfoDto timer, CancellationToken cancellationToken)
{
var info = await _tvDtoService.GetSeriesTimerInfo(timer, false, this, cancellationToken).ConfigureAwait(false);
2015-03-12 15:51:48 +00:00
var service = GetService(timer.ServiceName);
2013-12-17 20:02:12 +00:00
await service.UpdateSeriesTimerAsync(info, cancellationToken).ConfigureAwait(false);
2015-06-01 17:07:55 +00:00
_lastRecordingRefreshTime = DateTime.MinValue;
2013-12-17 20:02:12 +00:00
}
2013-12-28 21:37:01 +00:00
2015-06-01 17:07:55 +00:00
private IEnumerable<string> GetRecordingGroupNames(ILiveTvRecording recording)
2013-12-28 21:37:01 +00:00
{
var list = new List<string>();
if (recording.IsSeries)
{
list.Add(recording.Name);
}
if (recording.IsKids)
{
list.Add("Kids");
}
if (recording.IsMovie)
{
list.Add("Movies");
}
if (recording.IsNews)
{
list.Add("News");
}
2014-01-03 20:43:54 +00:00
if (recording.IsSports)
2013-12-28 21:37:01 +00:00
{
list.Add("Sports");
}
if (!recording.IsSports && !recording.IsNews && !recording.IsMovie && !recording.IsKids && !recording.IsSeries)
{
list.Add("Others");
}
2013-12-28 23:09:24 +00:00
2013-12-28 21:37:01 +00:00
return list;
}
2013-12-28 23:09:24 +00:00
2015-06-01 17:07:55 +00:00
private List<Guid> GetRecordingGroupIds(ILiveTvRecording recording)
2013-12-28 21:37:01 +00:00
{
return GetRecordingGroupNames(recording).Select(i => i.ToLower()
.GetMD5())
.ToList();
}
2015-05-31 18:22:51 +00:00
public async Task<QueryResult<BaseItemDto>> GetRecordingGroups(RecordingGroupQuery query, CancellationToken cancellationToken)
2013-12-28 21:37:01 +00:00
{
2015-05-31 18:22:51 +00:00
var recordingResult = await GetInternalRecordings(new RecordingQuery
2013-12-28 21:37:01 +00:00
{
UserId = query.UserId
2015-05-31 18:22:51 +00:00
}, cancellationToken).ConfigureAwait(false);
2013-12-28 21:37:01 +00:00
2015-05-31 18:22:51 +00:00
var recordings = recordingResult.Items.Cast<ILiveTvRecording>().ToList();
2013-12-28 21:37:01 +00:00
2015-05-31 18:22:51 +00:00
var groups = new List<BaseItemDto>();
2013-12-28 21:37:01 +00:00
var series = recordings
2015-06-01 17:07:55 +00:00
.Where(i => i.IsSeries)
2013-12-28 21:37:01 +00:00
.ToLookup(i => i.Name, StringComparer.OrdinalIgnoreCase)
.ToList();
2015-05-31 18:22:51 +00:00
groups.AddRange(series.OrderByString(i => i.Key).Select(i => new BaseItemDto
2013-12-28 21:37:01 +00:00
{
Name = i.Key,
RecordingCount = i.Count()
}));
2015-05-31 18:22:51 +00:00
groups.Add(new BaseItemDto
2013-12-28 21:37:01 +00:00
{
Name = "Kids",
2015-06-01 17:07:55 +00:00
RecordingCount = recordings.Count(i => i.IsKids)
2013-12-28 21:37:01 +00:00
});
2015-05-31 18:22:51 +00:00
groups.Add(new BaseItemDto
2013-12-28 21:37:01 +00:00
{
Name = "Movies",
2015-06-01 17:07:55 +00:00
RecordingCount = recordings.Count(i => i.IsMovie)
2013-12-28 21:37:01 +00:00
});
2015-05-31 18:22:51 +00:00
groups.Add(new BaseItemDto
2013-12-28 21:37:01 +00:00
{
Name = "News",
2015-06-01 17:07:55 +00:00
RecordingCount = recordings.Count(i => i.IsNews)
2013-12-28 21:37:01 +00:00
});
2015-05-31 18:22:51 +00:00
groups.Add(new BaseItemDto
2013-12-28 21:37:01 +00:00
{
Name = "Sports",
2015-06-01 17:07:55 +00:00
RecordingCount = recordings.Count(i => i.IsSports)
2013-12-28 21:37:01 +00:00
});
2015-05-31 18:22:51 +00:00
groups.Add(new BaseItemDto
2013-12-28 21:37:01 +00:00
{
Name = "Others",
2015-06-01 17:07:55 +00:00
RecordingCount = recordings.Count(i => !i.IsSports && !i.IsNews && !i.IsMovie && !i.IsKids && !i.IsSeries)
2013-12-28 21:37:01 +00:00
});
groups = groups
.Where(i => i.RecordingCount > 0)
.ToList();
foreach (var group in groups)
{
group.Id = group.Name.ToLower().GetMD5().ToString("N");
}
2015-05-31 18:22:51 +00:00
return new QueryResult<BaseItemDto>
2013-12-28 21:37:01 +00:00
{
Items = groups.ToArray(),
TotalRecordCount = groups.Count
};
}
2014-01-05 06:50:48 +00:00
2014-07-02 18:34:08 +00:00
class LiveStreamData
{
2015-03-20 05:40:51 +00:00
internal MediaSourceInfo Info;
2014-07-02 18:34:08 +00:00
internal string ItemId;
internal bool IsChannel;
}
2014-01-17 16:36:01 +00:00
public async Task CloseLiveStream(string id, CancellationToken cancellationToken)
2014-01-05 06:50:48 +00:00
{
2014-01-17 16:36:01 +00:00
await _liveStreamSemaphore.WaitAsync(cancellationToken).ConfigureAwait(false);
try
{
2015-03-30 03:04:55 +00:00
var parts = id.Split(new[] { '_' }, 2);
2014-07-02 18:34:08 +00:00
2015-03-30 03:04:55 +00:00
var service = _services.FirstOrDefault(i => string.Equals(i.GetType().FullName.GetMD5().ToString("N"), parts[0], StringComparison.OrdinalIgnoreCase));
2014-05-27 21:17:48 +00:00
2015-03-30 03:04:55 +00:00
if (service == null)
{
throw new ArgumentException("Service not found.");
2014-07-02 18:34:08 +00:00
}
2015-03-30 03:04:55 +00:00
id = parts[1];
LiveStreamData data;
2014-07-02 18:34:08 +00:00
_openStreams.TryRemove(id, out data);
_logger.Info("Closing live stream from {0}, stream Id: {1}", service.Name, id);
await service.CloseLiveStream(id, cancellationToken).ConfigureAwait(false);
2014-01-19 04:25:01 +00:00
}
catch (Exception ex)
{
_logger.ErrorException("Error closing live stream", ex);
throw;
2014-01-17 16:36:01 +00:00
}
finally
{
_liveStreamSemaphore.Release();
}
2014-01-05 06:50:48 +00:00
}
public GuideInfo GetGuideInfo()
{
2015-06-01 14:49:23 +00:00
var startDate = DateTime.UtcNow;
var endDate = startDate.AddDays(14);
return new GuideInfo
{
StartDate = startDate,
EndDate = endDate
};
}
2014-01-12 06:31:21 +00:00
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
/// </summary>
public void Dispose()
{
Dispose(true);
}
private readonly object _disposeLock = new object();
/// <summary>
/// Releases unmanaged and - optionally - managed resources.
/// </summary>
/// <param name="dispose"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
protected virtual void Dispose(bool dispose)
{
if (dispose)
{
lock (_disposeLock)
{
foreach (var stream in _openStreams.Values.ToList())
{
2014-07-02 18:34:08 +00:00
var task = CloseLiveStream(stream.Info.Id, CancellationToken.None);
2014-01-12 06:31:21 +00:00
Task.WaitAll(task);
}
_openStreams.Clear();
}
}
}
2014-01-16 17:23:30 +00:00
2014-01-23 22:15:15 +00:00
private async Task<IEnumerable<LiveTvServiceInfo>> GetServiceInfos(CancellationToken cancellationToken)
2014-01-16 17:23:30 +00:00
{
var tasks = Services.Select(i => GetServiceInfo(i, cancellationToken));
return await Task.WhenAll(tasks).ConfigureAwait(false);
}
private async Task<LiveTvServiceInfo> GetServiceInfo(ILiveTvService service, CancellationToken cancellationToken)
{
var info = new LiveTvServiceInfo
{
Name = service.Name
};
2015-03-30 03:04:55 +00:00
var tunerIdPrefix = service.GetType().FullName.GetMD5().ToString("N") + "_";
2014-01-16 17:23:30 +00:00
try
{
var statusInfo = await service.GetStatusInfoAsync(cancellationToken).ConfigureAwait(false);
info.Status = statusInfo.Status;
info.StatusMessage = statusInfo.StatusMessage;
2014-01-17 20:51:29 +00:00
info.Version = statusInfo.Version;
info.HasUpdateAvailable = statusInfo.HasUpdateAvailable;
info.HomePageUrl = service.HomePageUrl;
2015-07-21 04:22:46 +00:00
info.IsVisible = statusInfo.IsVisible;
2014-01-23 22:15:15 +00:00
2014-01-24 18:09:50 +00:00
info.Tuners = statusInfo.Tuners.Select(i =>
{
string channelName = null;
if (!string.IsNullOrEmpty(i.ChannelId))
{
var internalChannelId = _tvDtoService.GetInternalChannelId(service.Name, i.ChannelId);
var channel = GetInternalChannel(internalChannelId);
channelName = channel == null ? null : channel.Name;
}
2015-03-30 03:04:55 +00:00
var dto = _tvDtoService.GetTunerInfoDto(service.Name, i, channelName);
dto.Id = tunerIdPrefix + dto.Id;
return dto;
2014-01-24 18:09:50 +00:00
}).ToList();
2014-01-16 17:23:30 +00:00
}
catch (Exception ex)
{
2014-05-22 03:35:18 +00:00
_logger.ErrorException("Error getting service status info from {0}", ex, service.Name ?? string.Empty);
2014-01-16 17:23:30 +00:00
info.Status = LiveTvServiceStatus.Unavailable;
info.StatusMessage = ex.Message;
}
return info;
}
2014-01-23 22:15:15 +00:00
public async Task<LiveTvInfo> GetLiveTvInfo(CancellationToken cancellationToken)
{
var services = await GetServiceInfos(CancellationToken.None).ConfigureAwait(false);
var servicesList = services.ToList();
var info = new LiveTvInfo
{
Services = servicesList.ToList(),
2015-03-12 15:51:48 +00:00
IsEnabled = servicesList.Count > 0
2014-01-23 22:15:15 +00:00
};
info.EnabledUsers = _userManager.Users
2014-06-23 16:05:19 +00:00
.Where(IsLiveTvEnabled)
2014-01-23 22:15:15 +00:00
.Select(i => i.Id.ToString("N"))
.ToList();
return info;
}
2014-06-23 16:05:19 +00:00
private bool IsLiveTvEnabled(User user)
{
2015-07-27 16:21:18 +00:00
return user.Policy.EnableLiveTvAccess && (Services.Count > 1 || GetConfiguration().TunerHosts.Count(i => i.IsEnabled) > 0);
2014-06-23 16:05:19 +00:00
}
2014-06-10 17:36:06 +00:00
public IEnumerable<User> GetEnabledUsers()
{
return _userManager.Users
2015-03-12 14:59:08 +00:00
.Where(IsLiveTvEnabled);
2014-06-10 17:36:06 +00:00
}
2014-01-23 22:15:15 +00:00
/// <summary>
/// Resets the tuner.
/// </summary>
/// <param name="id">The identifier.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task.</returns>
public Task ResetTuner(string id, CancellationToken cancellationToken)
{
2015-03-30 03:04:55 +00:00
var parts = id.Split(new[] { '_' }, 2);
var service = _services.FirstOrDefault(i => string.Equals(i.GetType().FullName.GetMD5().ToString("N"), parts[0], StringComparison.OrdinalIgnoreCase));
if (service == null)
{
throw new ArgumentException("Service not found.");
}
return service.ResetTuner(parts[1], cancellationToken);
2014-01-23 22:15:15 +00:00
}
2014-06-07 19:46:24 +00:00
public async Task<BaseItemDto> GetLiveTvFolder(string userId, CancellationToken cancellationToken)
{
2014-09-14 15:10:51 +00:00
var user = string.IsNullOrEmpty(userId) ? null : _userManager.GetUserById(userId);
2014-06-07 19:46:24 +00:00
2015-08-14 19:14:54 +00:00
var folder = await GetInternalLiveTvFolder(cancellationToken).ConfigureAwait(false);
2014-06-07 19:46:24 +00:00
2014-12-27 05:08:39 +00:00
return _dtoService.GetBaseItemDto(folder, new DtoOptions(), user);
2014-06-07 19:46:24 +00:00
}
2015-08-14 19:14:54 +00:00
public async Task<Folder> GetInternalLiveTvFolder(CancellationToken cancellationToken)
2014-06-07 19:46:24 +00:00
{
var name = _localization.GetLocalizedString("ViewTypeLiveTV");
2015-11-22 23:06:11 +00:00
return await _libraryManager.GetNamedView(name, CollectionType.LiveTv, name, cancellationToken).ConfigureAwait(false);
2014-06-07 19:46:24 +00:00
}
2015-07-23 13:23:22 +00:00
2015-07-25 18:11:46 +00:00
public async Task<TunerHostInfo> SaveTunerHost(TunerHostInfo info)
2015-07-23 13:23:22 +00:00
{
info = (TunerHostInfo)_jsonSerializer.DeserializeFromString(_jsonSerializer.SerializeToString(info), typeof(TunerHostInfo));
2015-07-27 16:21:18 +00:00
2015-07-23 13:23:22 +00:00
var provider = _tunerHosts.FirstOrDefault(i => string.Equals(info.Type, i.Type, StringComparison.OrdinalIgnoreCase));
if (provider == null)
{
throw new ResourceNotFoundException();
}
await provider.Validate(info).ConfigureAwait(false);
var config = GetConfiguration();
var index = config.TunerHosts.FindIndex(i => string.Equals(i.Id, info.Id, StringComparison.OrdinalIgnoreCase));
if (index == -1 || string.IsNullOrWhiteSpace(info.Id))
{
info.Id = Guid.NewGuid().ToString("N");
config.TunerHosts.Add(info);
}
else
{
config.TunerHosts[index] = info;
}
_config.SaveConfiguration("livetv", config);
2015-07-23 17:04:54 +00:00
_taskManager.CancelIfRunningAndQueue<RefreshChannelsScheduledTask>();
2015-07-25 18:11:46 +00:00
return info;
2015-07-23 13:23:22 +00:00
}
2015-07-25 17:21:10 +00:00
public async Task<ListingsProviderInfo> SaveListingProvider(ListingsProviderInfo info, bool validateLogin, bool validateListings)
2015-07-23 13:23:22 +00:00
{
info = (ListingsProviderInfo)_jsonSerializer.DeserializeFromString(_jsonSerializer.SerializeToString(info), typeof(ListingsProviderInfo));
var provider = _listingProviders.FirstOrDefault(i => string.Equals(info.Type, i.Type, StringComparison.OrdinalIgnoreCase));
if (provider == null)
{
throw new ResourceNotFoundException();
}
2015-07-25 17:21:10 +00:00
await provider.Validate(info, validateLogin, validateListings).ConfigureAwait(false);
2015-07-23 13:23:22 +00:00
var config = GetConfiguration();
var index = config.ListingProviders.FindIndex(i => string.Equals(i.Id, info.Id, StringComparison.OrdinalIgnoreCase));
if (index == -1 || string.IsNullOrWhiteSpace(info.Id))
{
info.Id = Guid.NewGuid().ToString("N");
config.ListingProviders.Add(info);
}
else
{
config.ListingProviders[index] = info;
}
_config.SaveConfiguration("livetv", config);
2015-07-23 17:04:54 +00:00
_taskManager.CancelIfRunningAndQueue<RefreshChannelsScheduledTask>();
2015-07-27 16:21:18 +00:00
2015-07-23 13:23:22 +00:00
return info;
}
2015-08-10 19:09:10 +00:00
public Task<List<NameIdPair>> GetLineups(string providerType, string providerId, string country, string location)
2015-07-23 13:23:22 +00:00
{
var config = GetConfiguration();
2015-08-10 19:09:10 +00:00
if (string.IsNullOrWhiteSpace(providerId))
{
var provider = _listingProviders.FirstOrDefault(i => string.Equals(providerType, i.Type, StringComparison.OrdinalIgnoreCase));
2015-07-23 13:23:22 +00:00
2015-08-10 19:09:10 +00:00
if (provider == null)
{
throw new ResourceNotFoundException();
}
2015-07-23 13:23:22 +00:00
2015-08-10 19:09:10 +00:00
return provider.GetLineups(null, country, location);
2015-07-23 13:23:22 +00:00
}
2015-08-10 19:09:10 +00:00
else
{
var info = config.ListingProviders.FirstOrDefault(i => string.Equals(i.Id, providerId, StringComparison.OrdinalIgnoreCase));
2015-07-23 13:23:22 +00:00
2015-08-10 19:09:10 +00:00
var provider = _listingProviders.FirstOrDefault(i => string.Equals(info.Type, i.Type, StringComparison.OrdinalIgnoreCase));
if (provider == null)
{
throw new ResourceNotFoundException();
}
return provider.GetLineups(info, country, location);
}
2015-07-23 13:23:22 +00:00
}
2015-08-21 19:25:35 +00:00
public Task<MBRegistrationRecord> GetRegistrationInfo(string channelId, string programId, string feature)
{
ILiveTvService service;
if (string.IsNullOrWhiteSpace(programId))
{
var channel = GetInternalChannel(channelId);
service = GetService(channel);
}
else
{
var program = GetInternalProgram(programId);
service = GetService(program);
}
var hasRegistration = service as IHasRegistrationInfo;
if (hasRegistration != null)
{
return hasRegistration.GetRegistrationInfo(feature);
}
return Task.FromResult(new MBRegistrationRecord
{
IsValid = true,
IsRegistered = true
});
}
}
2015-09-21 16:26:05 +00:00
}