2015-08-03 01:47:31 +02:00
|
|
|
|
using MediaBrowser.Common;
|
2015-07-20 20:32:55 +02:00
|
|
|
|
using MediaBrowser.Common.Configuration;
|
2015-07-24 01:40:54 +02:00
|
|
|
|
using MediaBrowser.Common.Extensions;
|
2015-08-16 02:41:55 +02:00
|
|
|
|
using MediaBrowser.Common.IO;
|
2015-07-20 20:32:55 +02:00
|
|
|
|
using MediaBrowser.Common.Net;
|
|
|
|
|
using MediaBrowser.Controller.Drawing;
|
|
|
|
|
using MediaBrowser.Controller.LiveTv;
|
|
|
|
|
using MediaBrowser.Model.Dto;
|
|
|
|
|
using MediaBrowser.Model.Events;
|
|
|
|
|
using MediaBrowser.Model.LiveTv;
|
|
|
|
|
using MediaBrowser.Model.Logging;
|
|
|
|
|
using MediaBrowser.Model.Serialization;
|
|
|
|
|
using System;
|
|
|
|
|
using System.Collections.Concurrent;
|
|
|
|
|
using System.Collections.Generic;
|
2015-08-03 01:47:31 +02:00
|
|
|
|
using System.Globalization;
|
2015-07-20 20:32:55 +02:00
|
|
|
|
using System.IO;
|
|
|
|
|
using System.Linq;
|
|
|
|
|
using System.Threading;
|
|
|
|
|
using System.Threading.Tasks;
|
|
|
|
|
|
|
|
|
|
namespace MediaBrowser.Server.Implementations.LiveTv.EmbyTV
|
|
|
|
|
{
|
|
|
|
|
public class EmbyTV : ILiveTvService, IDisposable
|
|
|
|
|
{
|
2015-07-21 06:22:46 +02:00
|
|
|
|
private readonly IApplicationHost _appHpst;
|
2015-07-20 20:32:55 +02:00
|
|
|
|
private readonly ILogger _logger;
|
|
|
|
|
private readonly IHttpClient _httpClient;
|
|
|
|
|
private readonly IConfigurationManager _config;
|
|
|
|
|
private readonly IJsonSerializer _jsonSerializer;
|
|
|
|
|
|
|
|
|
|
private readonly ItemDataProvider<RecordingInfo> _recordingProvider;
|
|
|
|
|
private readonly ItemDataProvider<SeriesTimerInfo> _seriesTimerProvider;
|
|
|
|
|
private readonly TimerManager _timerProvider;
|
|
|
|
|
|
2015-07-23 15:23:22 +02:00
|
|
|
|
private readonly LiveTvManager _liveTvManager;
|
2015-08-16 20:54:25 +02:00
|
|
|
|
private readonly IFileSystem _fileSystem;
|
2015-07-23 07:25:55 +02:00
|
|
|
|
|
2015-07-29 05:42:03 +02:00
|
|
|
|
public static EmbyTV Current;
|
|
|
|
|
|
2015-08-16 20:54:25 +02:00
|
|
|
|
public EmbyTV(IApplicationHost appHost, ILogger logger, IJsonSerializer jsonSerializer, IHttpClient httpClient, IConfigurationManager config, ILiveTvManager liveTvManager, IFileSystem fileSystem)
|
2015-07-20 20:32:55 +02:00
|
|
|
|
{
|
2015-07-29 05:42:03 +02:00
|
|
|
|
Current = this;
|
|
|
|
|
|
2015-07-21 06:22:46 +02:00
|
|
|
|
_appHpst = appHost;
|
2015-07-20 20:32:55 +02:00
|
|
|
|
_logger = logger;
|
|
|
|
|
_httpClient = httpClient;
|
|
|
|
|
_config = config;
|
2015-08-16 20:54:25 +02:00
|
|
|
|
_fileSystem = fileSystem;
|
2015-07-23 15:23:22 +02:00
|
|
|
|
_liveTvManager = (LiveTvManager)liveTvManager;
|
2015-07-20 20:32:55 +02:00
|
|
|
|
_jsonSerializer = jsonSerializer;
|
|
|
|
|
|
|
|
|
|
_recordingProvider = new ItemDataProvider<RecordingInfo>(jsonSerializer, _logger, Path.Combine(DataPath, "recordings"), (r1, r2) => string.Equals(r1.Id, r2.Id, StringComparison.OrdinalIgnoreCase));
|
|
|
|
|
_seriesTimerProvider = new SeriesTimerManager(jsonSerializer, _logger, Path.Combine(DataPath, "seriestimers"));
|
|
|
|
|
_timerProvider = new TimerManager(jsonSerializer, _logger, Path.Combine(DataPath, "timers"));
|
|
|
|
|
_timerProvider.TimerFired += _timerProvider_TimerFired;
|
|
|
|
|
}
|
|
|
|
|
|
2015-07-29 05:42:03 +02:00
|
|
|
|
public void Start()
|
|
|
|
|
{
|
|
|
|
|
_timerProvider.RestartTimers();
|
|
|
|
|
}
|
|
|
|
|
|
2015-07-20 20:32:55 +02:00
|
|
|
|
public event EventHandler DataSourceChanged;
|
|
|
|
|
|
|
|
|
|
public event EventHandler<RecordingStatusChangedEventArgs> RecordingStatusChanged;
|
|
|
|
|
|
|
|
|
|
private readonly ConcurrentDictionary<string, CancellationTokenSource> _activeRecordings =
|
|
|
|
|
new ConcurrentDictionary<string, CancellationTokenSource>(StringComparer.OrdinalIgnoreCase);
|
|
|
|
|
|
|
|
|
|
public string Name
|
|
|
|
|
{
|
|
|
|
|
get { return "Emby"; }
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public string DataPath
|
|
|
|
|
{
|
|
|
|
|
get { return Path.Combine(_config.CommonApplicationPaths.DataPath, "livetv"); }
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public string HomePageUrl
|
|
|
|
|
{
|
|
|
|
|
get { return "http://emby.media"; }
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public async Task<LiveTvServiceStatusInfo> GetStatusInfoAsync(CancellationToken cancellationToken)
|
|
|
|
|
{
|
|
|
|
|
var status = new LiveTvServiceStatusInfo();
|
|
|
|
|
var list = new List<LiveTvTunerInfo>();
|
|
|
|
|
|
2015-07-24 01:40:54 +02:00
|
|
|
|
foreach (var hostInstance in GetTunerHosts())
|
2015-07-20 20:32:55 +02:00
|
|
|
|
{
|
2015-07-24 01:40:54 +02:00
|
|
|
|
try
|
2015-07-20 20:32:55 +02:00
|
|
|
|
{
|
2015-07-24 01:40:54 +02:00
|
|
|
|
var tuners = await hostInstance.Item1.GetTunerInfos(hostInstance.Item2, cancellationToken).ConfigureAwait(false);
|
2015-07-20 20:32:55 +02:00
|
|
|
|
|
2015-07-24 01:40:54 +02:00
|
|
|
|
list.AddRange(tuners);
|
|
|
|
|
}
|
|
|
|
|
catch (Exception ex)
|
|
|
|
|
{
|
|
|
|
|
_logger.ErrorException("Error getting tuners", ex);
|
2015-07-20 20:32:55 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
status.Tuners = list;
|
|
|
|
|
status.Status = LiveTvServiceStatus.Ok;
|
2015-07-21 06:22:46 +02:00
|
|
|
|
status.Version = _appHpst.ApplicationVersion.ToString();
|
|
|
|
|
status.IsVisible = false;
|
2015-07-20 20:32:55 +02:00
|
|
|
|
return status;
|
|
|
|
|
}
|
|
|
|
|
|
2015-08-16 20:54:25 +02:00
|
|
|
|
private List<ChannelInfo> _channelCache = null;
|
|
|
|
|
private async Task<IEnumerable<ChannelInfo>> GetChannelsAsync(bool enableCache, CancellationToken cancellationToken)
|
2015-07-20 20:32:55 +02:00
|
|
|
|
{
|
2015-08-16 20:54:25 +02:00
|
|
|
|
if (enableCache && _channelCache != null)
|
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
return _channelCache.ToList();
|
|
|
|
|
}
|
|
|
|
|
|
2015-07-20 20:32:55 +02:00
|
|
|
|
var list = new List<ChannelInfo>();
|
|
|
|
|
|
2015-07-24 01:40:54 +02:00
|
|
|
|
foreach (var hostInstance in GetTunerHosts())
|
2015-07-20 20:32:55 +02:00
|
|
|
|
{
|
2015-07-24 01:40:54 +02:00
|
|
|
|
try
|
2015-07-20 20:32:55 +02:00
|
|
|
|
{
|
2015-07-24 01:40:54 +02:00
|
|
|
|
var channels = await hostInstance.Item1.GetChannels(hostInstance.Item2, cancellationToken).ConfigureAwait(false);
|
2015-07-20 20:32:55 +02:00
|
|
|
|
|
2015-08-16 20:37:53 +02:00
|
|
|
|
list.AddRange(channels);
|
2015-07-24 01:40:54 +02:00
|
|
|
|
}
|
|
|
|
|
catch (Exception ex)
|
|
|
|
|
{
|
|
|
|
|
_logger.ErrorException("Error getting channels", ex);
|
2015-07-20 20:32:55 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2015-07-23 07:25:55 +02:00
|
|
|
|
if (list.Count > 0)
|
|
|
|
|
{
|
|
|
|
|
foreach (var provider in GetListingProviders())
|
|
|
|
|
{
|
2015-08-03 01:47:31 +02:00
|
|
|
|
try
|
|
|
|
|
{
|
|
|
|
|
await provider.Item1.AddMetadata(provider.Item2, list, cancellationToken).ConfigureAwait(false);
|
|
|
|
|
}
|
|
|
|
|
catch (NotSupportedException)
|
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
catch (Exception ex)
|
|
|
|
|
{
|
|
|
|
|
_logger.ErrorException("Error adding metadata", ex);
|
|
|
|
|
}
|
2015-07-23 07:25:55 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
2015-08-16 20:54:25 +02:00
|
|
|
|
_channelCache = list;
|
2015-07-20 20:32:55 +02:00
|
|
|
|
return list;
|
|
|
|
|
}
|
|
|
|
|
|
2015-08-16 20:54:25 +02:00
|
|
|
|
public Task<IEnumerable<ChannelInfo>> GetChannelsAsync(CancellationToken cancellationToken)
|
|
|
|
|
{
|
|
|
|
|
return GetChannelsAsync(false, cancellationToken);
|
|
|
|
|
}
|
|
|
|
|
|
2015-07-24 01:40:54 +02:00
|
|
|
|
private List<Tuple<ITunerHost, TunerHostInfo>> GetTunerHosts()
|
|
|
|
|
{
|
|
|
|
|
return GetConfiguration().TunerHosts
|
2015-07-27 18:21:18 +02:00
|
|
|
|
.Where(i => i.IsEnabled)
|
2015-07-24 01:40:54 +02:00
|
|
|
|
.Select(i =>
|
|
|
|
|
{
|
|
|
|
|
var provider = _liveTvManager.TunerHosts.FirstOrDefault(l => string.Equals(l.Type, i.Type, StringComparison.OrdinalIgnoreCase));
|
|
|
|
|
|
|
|
|
|
return provider == null ? null : new Tuple<ITunerHost, TunerHostInfo>(provider, i);
|
|
|
|
|
})
|
|
|
|
|
.Where(i => i != null)
|
|
|
|
|
.ToList();
|
|
|
|
|
}
|
|
|
|
|
|
2015-07-20 20:32:55 +02:00
|
|
|
|
public Task CancelSeriesTimerAsync(string timerId, CancellationToken cancellationToken)
|
|
|
|
|
{
|
2015-08-17 18:52:56 +02:00
|
|
|
|
var timers = _timerProvider.GetAll().Where(i => string.Equals(i.SeriesTimerId, timerId, StringComparison.OrdinalIgnoreCase));
|
|
|
|
|
foreach (var timer in timers)
|
|
|
|
|
{
|
|
|
|
|
CancelTimerInternal(timer.Id);
|
|
|
|
|
}
|
|
|
|
|
|
2015-07-29 05:42:03 +02:00
|
|
|
|
var remove = _seriesTimerProvider.GetAll().FirstOrDefault(r => string.Equals(r.Id, timerId, StringComparison.OrdinalIgnoreCase));
|
2015-07-20 20:32:55 +02:00
|
|
|
|
if (remove != null)
|
|
|
|
|
{
|
|
|
|
|
_seriesTimerProvider.Delete(remove);
|
|
|
|
|
}
|
|
|
|
|
return Task.FromResult(true);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private void CancelTimerInternal(string timerId)
|
|
|
|
|
{
|
2015-07-29 05:42:03 +02:00
|
|
|
|
var remove = _timerProvider.GetAll().FirstOrDefault(r => string.Equals(r.Id, timerId, StringComparison.OrdinalIgnoreCase));
|
2015-07-20 20:32:55 +02:00
|
|
|
|
if (remove != null)
|
|
|
|
|
{
|
|
|
|
|
_timerProvider.Delete(remove);
|
|
|
|
|
}
|
|
|
|
|
CancellationTokenSource cancellationTokenSource;
|
|
|
|
|
|
|
|
|
|
if (_activeRecordings.TryGetValue(timerId, out cancellationTokenSource))
|
|
|
|
|
{
|
|
|
|
|
cancellationTokenSource.Cancel();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public Task CancelTimerAsync(string timerId, CancellationToken cancellationToken)
|
|
|
|
|
{
|
|
|
|
|
CancelTimerInternal(timerId);
|
|
|
|
|
return Task.FromResult(true);
|
|
|
|
|
}
|
|
|
|
|
|
2015-07-29 05:42:03 +02:00
|
|
|
|
public async Task DeleteRecordingAsync(string recordingId, CancellationToken cancellationToken)
|
2015-07-20 20:32:55 +02:00
|
|
|
|
{
|
|
|
|
|
var remove = _recordingProvider.GetAll().FirstOrDefault(i => string.Equals(i.Id, recordingId, StringComparison.OrdinalIgnoreCase));
|
|
|
|
|
if (remove != null)
|
|
|
|
|
{
|
2015-07-29 05:42:03 +02:00
|
|
|
|
if (!string.IsNullOrWhiteSpace(remove.TimerId))
|
|
|
|
|
{
|
|
|
|
|
var enableDelay = _activeRecordings.ContainsKey(remove.TimerId);
|
|
|
|
|
|
|
|
|
|
CancelTimerInternal(remove.TimerId);
|
|
|
|
|
|
|
|
|
|
if (enableDelay)
|
|
|
|
|
{
|
|
|
|
|
// A hack yes, but need to make sure the file is closed before attempting to delete it
|
2015-08-16 22:26:49 +02:00
|
|
|
|
await Task.Delay(3000, cancellationToken).ConfigureAwait(false);
|
2015-07-29 05:42:03 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2015-07-20 20:32:55 +02:00
|
|
|
|
try
|
|
|
|
|
{
|
|
|
|
|
File.Delete(remove.Path);
|
|
|
|
|
}
|
|
|
|
|
catch (DirectoryNotFoundException)
|
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
catch (FileNotFoundException)
|
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
_recordingProvider.Delete(remove);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public Task CreateTimerAsync(TimerInfo info, CancellationToken cancellationToken)
|
|
|
|
|
{
|
|
|
|
|
info.Id = Guid.NewGuid().ToString("N");
|
|
|
|
|
_timerProvider.Add(info);
|
|
|
|
|
return Task.FromResult(0);
|
|
|
|
|
}
|
|
|
|
|
|
2015-08-15 23:58:52 +02:00
|
|
|
|
public async Task CreateSeriesTimerAsync(SeriesTimerInfo info, CancellationToken cancellationToken)
|
2015-07-20 20:32:55 +02:00
|
|
|
|
{
|
2015-07-29 19:16:00 +02:00
|
|
|
|
info.Id = Guid.NewGuid().ToString("N");
|
2015-07-20 20:32:55 +02:00
|
|
|
|
|
2015-08-17 00:03:22 +02:00
|
|
|
|
List<ProgramInfo> epgData;
|
|
|
|
|
if (info.RecordAnyChannel)
|
|
|
|
|
{
|
|
|
|
|
var channels = await GetChannelsAsync(true, CancellationToken.None).ConfigureAwait(false);
|
|
|
|
|
var channelIds = channels.Select(i => i.Id).ToList();
|
|
|
|
|
epgData = GetEpgDataForChannels(channelIds);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
epgData = GetEpgDataForChannel(info.ChannelId);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// populate info.seriesID
|
|
|
|
|
var program = epgData.FirstOrDefault(i => string.Equals(i.Id, info.ProgramId, StringComparison.OrdinalIgnoreCase));
|
|
|
|
|
|
|
|
|
|
if (program != null)
|
|
|
|
|
{
|
|
|
|
|
info.SeriesId = program.SeriesId;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
throw new InvalidOperationException("SeriesId for program not found");
|
|
|
|
|
}
|
|
|
|
|
|
2015-07-20 20:32:55 +02:00
|
|
|
|
_seriesTimerProvider.Add(info);
|
2015-08-17 00:03:22 +02:00
|
|
|
|
await UpdateTimersForSeriesTimer(epgData, info).ConfigureAwait(false);
|
2015-07-20 20:32:55 +02:00
|
|
|
|
}
|
|
|
|
|
|
2015-08-15 23:58:52 +02:00
|
|
|
|
public async Task UpdateSeriesTimerAsync(SeriesTimerInfo info, CancellationToken cancellationToken)
|
2015-07-20 20:32:55 +02:00
|
|
|
|
{
|
|
|
|
|
_seriesTimerProvider.Update(info);
|
2015-08-17 00:03:22 +02:00
|
|
|
|
List<ProgramInfo> epgData;
|
|
|
|
|
if (info.RecordAnyChannel)
|
|
|
|
|
{
|
|
|
|
|
var channels = await GetChannelsAsync(true, CancellationToken.None).ConfigureAwait(false);
|
|
|
|
|
var channelIds = channels.Select(i => i.Id).ToList();
|
|
|
|
|
epgData = GetEpgDataForChannels(channelIds);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
epgData = GetEpgDataForChannel(info.ChannelId);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
await UpdateTimersForSeriesTimer(epgData, info).ConfigureAwait(false);
|
2015-07-20 20:32:55 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public Task UpdateTimerAsync(TimerInfo info, CancellationToken cancellationToken)
|
|
|
|
|
{
|
|
|
|
|
_timerProvider.Update(info);
|
|
|
|
|
return Task.FromResult(true);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public Task<ImageStream> GetChannelImageAsync(string channelId, CancellationToken cancellationToken)
|
|
|
|
|
{
|
|
|
|
|
throw new NotImplementedException();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public Task<ImageStream> GetRecordingImageAsync(string recordingId, CancellationToken cancellationToken)
|
|
|
|
|
{
|
|
|
|
|
throw new NotImplementedException();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public Task<ImageStream> GetProgramImageAsync(string programId, string channelId, CancellationToken cancellationToken)
|
|
|
|
|
{
|
|
|
|
|
throw new NotImplementedException();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public Task<IEnumerable<RecordingInfo>> GetRecordingsAsync(CancellationToken cancellationToken)
|
|
|
|
|
{
|
|
|
|
|
return Task.FromResult((IEnumerable<RecordingInfo>)_recordingProvider.GetAll());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public Task<IEnumerable<TimerInfo>> GetTimersAsync(CancellationToken cancellationToken)
|
|
|
|
|
{
|
|
|
|
|
return Task.FromResult((IEnumerable<TimerInfo>)_timerProvider.GetAll());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public Task<SeriesTimerInfo> GetNewTimerDefaultsAsync(CancellationToken cancellationToken, ProgramInfo program = null)
|
|
|
|
|
{
|
|
|
|
|
var defaults = new SeriesTimerInfo()
|
|
|
|
|
{
|
|
|
|
|
PostPaddingSeconds = 60,
|
|
|
|
|
PrePaddingSeconds = 60,
|
|
|
|
|
RecordAnyChannel = false,
|
|
|
|
|
RecordAnyTime = false,
|
|
|
|
|
RecordNewOnly = false
|
|
|
|
|
};
|
2015-08-11 19:47:29 +02:00
|
|
|
|
|
|
|
|
|
if (program != null)
|
|
|
|
|
{
|
|
|
|
|
defaults.SeriesId = program.SeriesId;
|
|
|
|
|
defaults.ProgramId = program.Id;
|
|
|
|
|
}
|
|
|
|
|
|
2015-07-20 20:32:55 +02:00
|
|
|
|
return Task.FromResult(defaults);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public Task<IEnumerable<SeriesTimerInfo>> GetSeriesTimersAsync(CancellationToken cancellationToken)
|
|
|
|
|
{
|
|
|
|
|
return Task.FromResult((IEnumerable<SeriesTimerInfo>)_seriesTimerProvider.GetAll());
|
|
|
|
|
}
|
|
|
|
|
|
2015-07-23 07:25:55 +02:00
|
|
|
|
public async Task<IEnumerable<ProgramInfo>> GetProgramsAsync(string channelId, DateTime startDateUtc, DateTime endDateUtc, CancellationToken cancellationToken)
|
2015-07-20 20:32:55 +02:00
|
|
|
|
{
|
2015-08-16 20:54:25 +02:00
|
|
|
|
var channels = await GetChannelsAsync(true, cancellationToken).ConfigureAwait(false);
|
|
|
|
|
var channel = channels.First(i => string.Equals(i.Id, channelId, StringComparison.OrdinalIgnoreCase));
|
|
|
|
|
|
2015-07-23 07:25:55 +02:00
|
|
|
|
foreach (var provider in GetListingProviders())
|
|
|
|
|
{
|
2015-08-16 20:54:25 +02:00
|
|
|
|
var programs = await provider.Item1.GetProgramsAsync(provider.Item2, channel.Number, startDateUtc, endDateUtc, cancellationToken)
|
2015-07-23 07:25:55 +02:00
|
|
|
|
.ConfigureAwait(false);
|
|
|
|
|
var list = programs.ToList();
|
|
|
|
|
|
2015-07-24 01:40:54 +02:00
|
|
|
|
// Replace the value that came from the provider with a normalized value
|
|
|
|
|
foreach (var program in list)
|
|
|
|
|
{
|
|
|
|
|
program.ChannelId = channelId;
|
|
|
|
|
}
|
|
|
|
|
|
2015-07-23 07:25:55 +02:00
|
|
|
|
if (list.Count > 0)
|
|
|
|
|
{
|
2015-07-29 05:42:03 +02:00
|
|
|
|
SaveEpgDataForChannel(channelId, list);
|
|
|
|
|
|
2015-07-23 07:25:55 +02:00
|
|
|
|
return list;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return new List<ProgramInfo>();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private List<Tuple<IListingsProvider, ListingsProviderInfo>> GetListingProviders()
|
|
|
|
|
{
|
|
|
|
|
return GetConfiguration().ListingProviders
|
|
|
|
|
.Select(i =>
|
|
|
|
|
{
|
2015-07-23 15:23:22 +02:00
|
|
|
|
var provider = _liveTvManager.ListingProviders.FirstOrDefault(l => string.Equals(l.Type, i.Type, StringComparison.OrdinalIgnoreCase));
|
2015-07-23 07:25:55 +02:00
|
|
|
|
|
|
|
|
|
return provider == null ? null : new Tuple<IListingsProvider, ListingsProviderInfo>(provider, i);
|
|
|
|
|
})
|
|
|
|
|
.Where(i => i != null)
|
|
|
|
|
.ToList();
|
2015-07-20 20:32:55 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public Task<MediaSourceInfo> GetRecordingStream(string recordingId, string streamId, CancellationToken cancellationToken)
|
|
|
|
|
{
|
|
|
|
|
throw new NotImplementedException();
|
|
|
|
|
}
|
|
|
|
|
|
2015-07-24 01:40:54 +02:00
|
|
|
|
public async Task<MediaSourceInfo> GetChannelStream(string channelId, string streamId, CancellationToken cancellationToken)
|
2015-07-20 20:32:55 +02:00
|
|
|
|
{
|
2015-07-24 01:40:54 +02:00
|
|
|
|
_logger.Info("Streaming Channel " + channelId);
|
|
|
|
|
|
|
|
|
|
foreach (var hostInstance in GetTunerHosts())
|
|
|
|
|
{
|
|
|
|
|
if (!string.IsNullOrWhiteSpace(streamId))
|
|
|
|
|
{
|
|
|
|
|
var originalStreamId = string.Join("-", streamId.Split('-').Skip(1).ToArray());
|
|
|
|
|
|
|
|
|
|
if (!string.Equals(hostInstance.Item2.Id, originalStreamId, StringComparison.OrdinalIgnoreCase))
|
|
|
|
|
{
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
MediaSourceInfo mediaSourceInfo = null;
|
|
|
|
|
try
|
|
|
|
|
{
|
2015-08-16 20:37:53 +02:00
|
|
|
|
mediaSourceInfo = await hostInstance.Item1.GetChannelStream(hostInstance.Item2, channelId, streamId, cancellationToken).ConfigureAwait(false);
|
2015-07-24 01:40:54 +02:00
|
|
|
|
}
|
2015-08-16 20:37:53 +02:00
|
|
|
|
catch (Exception e)
|
2015-07-24 01:40:54 +02:00
|
|
|
|
{
|
2015-08-16 20:37:53 +02:00
|
|
|
|
_logger.ErrorException("Error getting channel stream", e);
|
2015-07-24 01:40:54 +02:00
|
|
|
|
}
|
|
|
|
|
|
2015-08-16 20:37:53 +02:00
|
|
|
|
if (mediaSourceInfo != null)
|
|
|
|
|
{
|
|
|
|
|
mediaSourceInfo.Id = Guid.NewGuid().ToString("N");
|
|
|
|
|
return mediaSourceInfo;
|
|
|
|
|
}
|
2015-07-24 01:40:54 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
throw new ApplicationException("Tuner not found.");
|
2015-07-20 20:32:55 +02:00
|
|
|
|
}
|
|
|
|
|
|
2015-07-24 01:40:54 +02:00
|
|
|
|
public async Task<List<MediaSourceInfo>> GetChannelStreamMediaSources(string channelId, CancellationToken cancellationToken)
|
2015-07-20 20:32:55 +02:00
|
|
|
|
{
|
2015-07-24 01:40:54 +02:00
|
|
|
|
foreach (var hostInstance in GetTunerHosts())
|
|
|
|
|
{
|
2015-08-16 20:37:53 +02:00
|
|
|
|
try
|
2015-07-24 01:40:54 +02:00
|
|
|
|
{
|
2015-08-16 20:37:53 +02:00
|
|
|
|
var sources = await hostInstance.Item1.GetChannelStreamMediaSources(hostInstance.Item2, channelId, cancellationToken).ConfigureAwait(false);
|
2015-07-24 01:40:54 +02:00
|
|
|
|
|
|
|
|
|
foreach (var source in sources)
|
|
|
|
|
{
|
|
|
|
|
source.Id = hostInstance.Item2.Id + "-" + source.Id;
|
|
|
|
|
}
|
|
|
|
|
|
2015-08-16 20:37:53 +02:00
|
|
|
|
if (sources.Count > 0)
|
|
|
|
|
{
|
|
|
|
|
return sources;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
catch (NotImplementedException)
|
|
|
|
|
{
|
2015-08-16 20:54:25 +02:00
|
|
|
|
|
2015-07-24 01:40:54 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
throw new ApplicationException("Tuner not found.");
|
2015-07-20 20:32:55 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public Task<List<MediaSourceInfo>> GetRecordingStreamMediaSources(string recordingId, CancellationToken cancellationToken)
|
|
|
|
|
{
|
|
|
|
|
throw new NotImplementedException();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public Task CloseLiveStream(string id, CancellationToken cancellationToken)
|
|
|
|
|
{
|
|
|
|
|
return Task.FromResult(0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public Task RecordLiveStream(string id, CancellationToken cancellationToken)
|
|
|
|
|
{
|
|
|
|
|
return Task.FromResult(0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public Task ResetTuner(string id, CancellationToken cancellationToken)
|
|
|
|
|
{
|
|
|
|
|
return Task.FromResult(0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
async void _timerProvider_TimerFired(object sender, GenericEventArgs<TimerInfo> e)
|
|
|
|
|
{
|
|
|
|
|
try
|
|
|
|
|
{
|
|
|
|
|
var cancellationTokenSource = new CancellationTokenSource();
|
|
|
|
|
|
|
|
|
|
if (_activeRecordings.TryAdd(e.Argument.Id, cancellationTokenSource))
|
|
|
|
|
{
|
|
|
|
|
await RecordStream(e.Argument, cancellationTokenSource.Token).ConfigureAwait(false);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
catch (OperationCanceledException)
|
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
catch (Exception ex)
|
|
|
|
|
{
|
|
|
|
|
_logger.ErrorException("Error recording stream", ex);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private async Task RecordStream(TimerInfo timer, CancellationToken cancellationToken)
|
|
|
|
|
{
|
2015-07-28 05:32:33 +02:00
|
|
|
|
if (timer == null)
|
|
|
|
|
{
|
|
|
|
|
throw new ArgumentNullException("timer");
|
|
|
|
|
}
|
|
|
|
|
|
2015-07-27 20:18:10 +02:00
|
|
|
|
var mediaStreamInfo = await GetChannelStream(timer.ChannelId, null, CancellationToken.None);
|
2015-07-29 22:31:15 +02:00
|
|
|
|
var duration = (timer.EndDate - DateTime.UtcNow).Add(TimeSpan.FromSeconds(timer.PostPaddingSeconds));
|
2015-07-20 20:32:55 +02:00
|
|
|
|
|
|
|
|
|
HttpRequestOptions httpRequestOptions = new HttpRequestOptions()
|
|
|
|
|
{
|
2015-08-17 06:08:33 +02:00
|
|
|
|
Url = mediaStreamInfo.Path
|
2015-07-20 20:32:55 +02:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
var info = GetProgramInfoFromCache(timer.ChannelId, timer.ProgramId);
|
|
|
|
|
var recordPath = RecordingPath;
|
|
|
|
|
if (info.IsMovie)
|
|
|
|
|
{
|
2015-08-16 02:41:55 +02:00
|
|
|
|
recordPath = Path.Combine(recordPath, "Movies", _fileSystem.GetValidFilename(info.Name));
|
2015-07-20 20:32:55 +02:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2015-08-16 02:41:55 +02:00
|
|
|
|
recordPath = Path.Combine(recordPath, "TV", _fileSystem.GetValidFilename(info.Name));
|
2015-07-20 20:32:55 +02:00
|
|
|
|
}
|
|
|
|
|
|
2015-08-16 02:41:55 +02:00
|
|
|
|
recordPath = Path.Combine(recordPath, _fileSystem.GetValidFilename(RecordingHelper.GetRecordingName(timer, info)));
|
2015-07-20 20:32:55 +02:00
|
|
|
|
Directory.CreateDirectory(Path.GetDirectoryName(recordPath));
|
|
|
|
|
|
2015-07-29 05:42:03 +02:00
|
|
|
|
var recording = _recordingProvider.GetAll().FirstOrDefault(x => string.Equals(x.ProgramId, info.Id, StringComparison.OrdinalIgnoreCase));
|
2015-07-20 20:32:55 +02:00
|
|
|
|
|
|
|
|
|
if (recording == null)
|
|
|
|
|
{
|
2015-08-04 16:26:36 +02:00
|
|
|
|
recording = new RecordingInfo
|
2015-07-20 20:32:55 +02:00
|
|
|
|
{
|
|
|
|
|
ChannelId = info.ChannelId,
|
2015-07-29 05:42:03 +02:00
|
|
|
|
Id = Guid.NewGuid().ToString("N"),
|
2015-07-20 20:32:55 +02:00
|
|
|
|
StartDate = info.StartDate,
|
|
|
|
|
EndDate = info.EndDate,
|
2015-08-04 16:26:36 +02:00
|
|
|
|
Genres = info.Genres,
|
2015-07-20 20:32:55 +02:00
|
|
|
|
IsKids = info.IsKids,
|
|
|
|
|
IsLive = info.IsLive,
|
|
|
|
|
IsMovie = info.IsMovie,
|
|
|
|
|
IsHD = info.IsHD,
|
|
|
|
|
IsNews = info.IsNews,
|
|
|
|
|
IsPremiere = info.IsPremiere,
|
|
|
|
|
IsSeries = info.IsSeries,
|
|
|
|
|
IsSports = info.IsSports,
|
|
|
|
|
IsRepeat = !info.IsPremiere,
|
|
|
|
|
Name = info.Name,
|
2015-08-04 16:26:36 +02:00
|
|
|
|
EpisodeTitle = info.EpisodeTitle,
|
2015-07-20 20:32:55 +02:00
|
|
|
|
ProgramId = info.Id,
|
2015-08-04 16:26:36 +02:00
|
|
|
|
HasImage = info.HasImage,
|
|
|
|
|
ImagePath = info.ImagePath,
|
2015-07-20 20:32:55 +02:00
|
|
|
|
ImageUrl = info.ImageUrl,
|
|
|
|
|
OriginalAirDate = info.OriginalAirDate,
|
|
|
|
|
Status = RecordingStatus.Scheduled,
|
|
|
|
|
Overview = info.Overview,
|
2015-08-11 19:47:29 +02:00
|
|
|
|
SeriesTimerId = timer.SeriesTimerId,
|
|
|
|
|
TimerId = timer.Id,
|
|
|
|
|
ShowId = info.ShowId
|
2015-07-20 20:32:55 +02:00
|
|
|
|
};
|
|
|
|
|
_recordingProvider.Add(recording);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
recording.Path = recordPath;
|
|
|
|
|
recording.Status = RecordingStatus.InProgress;
|
2015-08-18 17:25:57 +02:00
|
|
|
|
recording.DateLastUpdated = DateTime.UtcNow;
|
2015-07-20 20:32:55 +02:00
|
|
|
|
_recordingProvider.Update(recording);
|
|
|
|
|
|
|
|
|
|
try
|
|
|
|
|
{
|
|
|
|
|
httpRequestOptions.BufferContent = false;
|
2015-07-29 22:31:15 +02:00
|
|
|
|
var durationToken = new CancellationTokenSource(duration);
|
|
|
|
|
var linkedToken = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, durationToken.Token).Token;
|
|
|
|
|
httpRequestOptions.CancellationToken = linkedToken;
|
2015-07-20 20:32:55 +02:00
|
|
|
|
_logger.Info("Writing file to path: " + recordPath);
|
|
|
|
|
using (var response = await _httpClient.SendAsync(httpRequestOptions, "GET"))
|
|
|
|
|
{
|
|
|
|
|
using (var output = File.Open(recordPath, FileMode.Create, FileAccess.Write, FileShare.Read))
|
|
|
|
|
{
|
2015-08-17 18:52:56 +02:00
|
|
|
|
await response.Content.CopyToAsync(output, StreamDefaults.DefaultCopyToBufferSize, linkedToken);
|
2015-07-20 20:32:55 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
recording.Status = RecordingStatus.Completed;
|
2015-08-05 05:43:54 +02:00
|
|
|
|
_logger.Info("Recording completed");
|
2015-07-20 20:32:55 +02:00
|
|
|
|
}
|
|
|
|
|
catch (OperationCanceledException)
|
|
|
|
|
{
|
2015-08-18 17:25:57 +02:00
|
|
|
|
_logger.Info("Recording stopped");
|
2015-07-29 22:31:15 +02:00
|
|
|
|
recording.Status = RecordingStatus.Completed;
|
2015-07-20 20:32:55 +02:00
|
|
|
|
}
|
2015-08-05 05:43:54 +02:00
|
|
|
|
catch (Exception ex)
|
2015-07-20 20:32:55 +02:00
|
|
|
|
{
|
2015-08-05 05:43:54 +02:00
|
|
|
|
_logger.ErrorException("Error recording", ex);
|
2015-07-20 20:32:55 +02:00
|
|
|
|
recording.Status = RecordingStatus.Error;
|
|
|
|
|
}
|
|
|
|
|
|
2015-08-18 17:25:57 +02:00
|
|
|
|
recording.DateLastUpdated = DateTime.UtcNow;
|
2015-07-20 20:32:55 +02:00
|
|
|
|
_recordingProvider.Update(recording);
|
|
|
|
|
_timerProvider.Delete(timer);
|
|
|
|
|
_logger.Info("Recording was a success");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private ProgramInfo GetProgramInfoFromCache(string channelId, string programId)
|
|
|
|
|
{
|
|
|
|
|
var epgData = GetEpgDataForChannel(channelId);
|
2015-08-18 06:22:45 +02:00
|
|
|
|
return epgData.FirstOrDefault(p => string.Equals(p.Id, programId, StringComparison.OrdinalIgnoreCase));
|
2015-07-20 20:32:55 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private string RecordingPath
|
|
|
|
|
{
|
|
|
|
|
get
|
|
|
|
|
{
|
|
|
|
|
var path = GetConfiguration().RecordingPath;
|
|
|
|
|
|
|
|
|
|
return string.IsNullOrWhiteSpace(path)
|
|
|
|
|
? Path.Combine(DataPath, "recordings")
|
|
|
|
|
: path;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private LiveTvOptions GetConfiguration()
|
|
|
|
|
{
|
|
|
|
|
return _config.GetConfiguration<LiveTvOptions>("livetv");
|
|
|
|
|
}
|
|
|
|
|
|
2015-08-17 00:03:22 +02:00
|
|
|
|
private async Task UpdateTimersForSeriesTimer(List<ProgramInfo> epgData, SeriesTimerInfo seriesTimer)
|
2015-07-20 20:32:55 +02:00
|
|
|
|
{
|
2015-07-29 19:16:00 +02:00
|
|
|
|
var newTimers = GetTimersForSeries(seriesTimer, epgData, _recordingProvider.GetAll()).ToList();
|
2015-07-20 20:32:55 +02:00
|
|
|
|
|
|
|
|
|
var existingTimers = _timerProvider.GetAll()
|
|
|
|
|
.Where(i => string.Equals(i.SeriesTimerId, seriesTimer.Id, StringComparison.OrdinalIgnoreCase))
|
|
|
|
|
.ToList();
|
|
|
|
|
|
|
|
|
|
foreach (var timer in newTimers)
|
|
|
|
|
{
|
|
|
|
|
_timerProvider.AddOrUpdate(timer);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
var newTimerIds = newTimers.Select(i => i.Id).ToList();
|
|
|
|
|
|
|
|
|
|
foreach (var timer in existingTimers)
|
|
|
|
|
{
|
|
|
|
|
if (!newTimerIds.Contains(timer.Id, StringComparer.OrdinalIgnoreCase))
|
|
|
|
|
{
|
|
|
|
|
CancelTimerInternal(timer.Id);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2015-07-29 19:16:00 +02:00
|
|
|
|
private IEnumerable<TimerInfo> GetTimersForSeries(SeriesTimerInfo seriesTimer, IEnumerable<ProgramInfo> allPrograms, IReadOnlyList<RecordingInfo> currentRecordings)
|
|
|
|
|
{
|
2015-08-17 18:52:56 +02:00
|
|
|
|
// Exclude programs that have already ended
|
|
|
|
|
allPrograms = allPrograms.Where(i => i.EndDate > DateTime.UtcNow);
|
|
|
|
|
|
2015-07-29 19:16:00 +02:00
|
|
|
|
allPrograms = GetProgramsForSeries(seriesTimer, allPrograms);
|
|
|
|
|
|
2015-08-18 06:22:45 +02:00
|
|
|
|
var recordingShowIds = currentRecordings.Select(i => i.ProgramId).Where(i => !string.IsNullOrWhiteSpace(i)).ToList();
|
2015-08-11 19:47:29 +02:00
|
|
|
|
|
2015-08-18 06:22:45 +02:00
|
|
|
|
allPrograms = allPrograms.Where(i => !recordingShowIds.Contains(i.Id, StringComparer.OrdinalIgnoreCase));
|
2015-07-29 19:16:00 +02:00
|
|
|
|
|
|
|
|
|
return allPrograms.Select(i => RecordingHelper.CreateTimer(i, seriesTimer));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private IEnumerable<ProgramInfo> GetProgramsForSeries(SeriesTimerInfo seriesTimer, IEnumerable<ProgramInfo> allPrograms)
|
|
|
|
|
{
|
|
|
|
|
if (!seriesTimer.RecordAnyTime)
|
|
|
|
|
{
|
|
|
|
|
allPrograms = allPrograms.Where(epg => (seriesTimer.StartDate.TimeOfDay == epg.StartDate.TimeOfDay));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (seriesTimer.RecordNewOnly)
|
|
|
|
|
{
|
2015-08-16 20:37:53 +02:00
|
|
|
|
allPrograms = allPrograms.Where(epg => !epg.IsRepeat);
|
2015-07-29 19:16:00 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!seriesTimer.RecordAnyChannel)
|
|
|
|
|
{
|
|
|
|
|
allPrograms = allPrograms.Where(epg => string.Equals(epg.ChannelId, seriesTimer.ChannelId, StringComparison.OrdinalIgnoreCase));
|
|
|
|
|
}
|
|
|
|
|
|
2015-08-18 18:32:18 +02:00
|
|
|
|
allPrograms = allPrograms.Where(i => seriesTimer.Days.Contains(i.StartDate.ToLocalTime().DayOfWeek));
|
2015-07-29 19:16:00 +02:00
|
|
|
|
|
2015-08-16 20:37:53 +02:00
|
|
|
|
if (string.IsNullOrWhiteSpace(seriesTimer.SeriesId))
|
|
|
|
|
{
|
|
|
|
|
_logger.Error("seriesTimer.SeriesId is null. Cannot find programs for series");
|
|
|
|
|
return new List<ProgramInfo>();
|
|
|
|
|
}
|
|
|
|
|
|
2015-08-15 23:58:52 +02:00
|
|
|
|
return allPrograms.Where(i => string.Equals(i.SeriesId, seriesTimer.SeriesId, StringComparison.OrdinalIgnoreCase));
|
2015-07-29 19:16:00 +02:00
|
|
|
|
}
|
2015-08-03 01:47:31 +02:00
|
|
|
|
|
2015-07-20 20:32:55 +02:00
|
|
|
|
private string GetChannelEpgCachePath(string channelId)
|
|
|
|
|
{
|
|
|
|
|
return Path.Combine(DataPath, "epg", channelId + ".json");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private readonly object _epgLock = new object();
|
|
|
|
|
private void SaveEpgDataForChannel(string channelId, List<ProgramInfo> epgData)
|
|
|
|
|
{
|
|
|
|
|
var path = GetChannelEpgCachePath(channelId);
|
|
|
|
|
Directory.CreateDirectory(Path.GetDirectoryName(path));
|
|
|
|
|
lock (_epgLock)
|
|
|
|
|
{
|
|
|
|
|
_jsonSerializer.SerializeToFile(epgData, path);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
private List<ProgramInfo> GetEpgDataForChannel(string channelId)
|
|
|
|
|
{
|
|
|
|
|
try
|
|
|
|
|
{
|
|
|
|
|
lock (_epgLock)
|
|
|
|
|
{
|
|
|
|
|
return _jsonSerializer.DeserializeFromFile<List<ProgramInfo>>(GetChannelEpgCachePath(channelId));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
catch
|
|
|
|
|
{
|
|
|
|
|
return new List<ProgramInfo>();
|
|
|
|
|
}
|
|
|
|
|
}
|
2015-08-15 23:58:52 +02:00
|
|
|
|
private List<ProgramInfo> GetEpgDataForChannels(List<string> channelIds)
|
2015-07-20 20:32:55 +02:00
|
|
|
|
{
|
2015-08-15 23:58:52 +02:00
|
|
|
|
return channelIds.SelectMany(GetEpgDataForChannel).ToList();
|
2015-07-20 20:32:55 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public void Dispose()
|
|
|
|
|
{
|
|
|
|
|
foreach (var pair in _activeRecordings.ToList())
|
|
|
|
|
{
|
|
|
|
|
pair.Value.Cancel();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|