public static void Register(HttpConfiguration config)
{
// Web API configuration and services registration
var container = new UnityContainer();
var dataAccessRegistration = new DataAccessRegistration();
var repositoryRegistation = new RepositoryRegistration();
var serviceRegistration = new ServiceRegistration();
dataAccessRegistration.Register(container);
repositoryRegistation.Register(container);
serviceRegistration.Register(container);
config.DependencyResolver = new UnityResolver(container);
config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
config.Formatters.JsonFormatter.UseDataContractJsonSerializer = false;
// Web API routes
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
}
public void Equals_ComparedToNull_AreNotEqual()
{
var firstRegistration = new ServiceRegistration();
firstRegistration.ServiceType = typeof(int);
firstRegistration.ServiceName = string.Empty;
Assert.IsFalse(firstRegistration.Equals(null));
}
public void Equals_SameTypeSameServiceName_AreEqual()
{
var firstRegistration = new ServiceRegistration();
firstRegistration.ServiceType = typeof(int);
firstRegistration.ServiceName = string.Empty;
var secondRegistration = new ServiceRegistration();
secondRegistration.ServiceType = typeof(int);
secondRegistration.ServiceName = string.Empty;
Assert.AreEqual(firstRegistration, secondRegistration);
}
public void Equals_SameTypeDifferentServiceName_AreNotEqual()
{
var firstRegistration = new ServiceRegistration();
firstRegistration.ServiceType = typeof(int);
firstRegistration.ServiceName = string.Empty;
var secondRegistration = new ServiceRegistration();
secondRegistration.ServiceType = typeof(int);
secondRegistration.ServiceName = "SomeName";
Assert.NotEqual(firstRegistration, secondRegistration);
}
private bool Match(ServiceRegistration sr)
{
if (sr.ImplementingType != null)
{
var methods = sr.ImplementingType.GetMethods();
if (methods.Select(methodInfo => methodInfo.GetCustomAttributes(typeof(AbstractAspectAttribute), true)).Any(attributes => attributes.Length > 0))
{
return true;
}
}
return false;
}
public int CompareTo(StringId other)
{
return(string.Compare(ToString(), other.ToString(), false, ServiceRegistration.Get <ILocalization>().CurrentCulture));
}
/// <summary>
/// Schedules an asynchronous call to <see cref="CheckMediaWorkflowStates_NoLock"/> at the global thread pool.
/// </summary>
protected void CheckMediaWorkflowStates_Async()
{
ServiceRegistration.Get <IThreadPool>().Add(new DoWorkHandler(CheckMediaWorkflowStates_NoLock), "PlayerContextManager: CheckMediaWorkflowStates");
}
public bool Play(MediaItem mediaItem, StartTime startTime)
{
IPlayer player = null;
try
{
IReusablePlayer rp;
lock (SyncObj)
{
CheckActive();
player = _player;
rp = _player as IReusablePlayer;
}
if (rp != null)
{
if (rp.NextItem(mediaItem, startTime))
{
OnPlayerStarted(rp);
return(true);
}
}
ReleasePlayer_NoLock();
ICollection <Exception> exceptions;
player = _playerManager.BuildPlayer_NoLock(mediaItem, out exceptions);
if (player == null)
{
HandleUnableToPlay(mediaItem, exceptions);
OnPlaybackError(null);
}
else
{
IMediaPlaybackControl mpc;
IDisposable disposePlayer = null;
lock (SyncObj)
{
if (_player != null)
{
disposePlayer = _player as IDisposable; // If we got a race condition between the locks
}
_player = player;
mpc = player as IMediaPlaybackControl;
}
RegisterPlayerEvents_NoLock(player);
CheckAudio_NoLock();
if (disposePlayer != null)
{
disposePlayer.Dispose();
}
OnPlayerStarted(player);
// Handling of resume info.
object resumeObject;
if (ContextVariables.TryGetValue(PlayerContext.KEY_RESUME_STATE, out resumeObject))
{
IResumeState resumeState = (IResumeState)resumeObject;
IResumablePlayer resumablePlayer = player as IResumablePlayer;
if (resumablePlayer != null)
{
resumablePlayer.SetResumeState(resumeState);
}
}
if (mpc != null)
{
mpc.Resume();
}
return(true);
}
return(false);
}
catch (Exception e)
{
ServiceRegistration.Get <ILogger>().Warn("PlayerSlotController: Error playing '{0}'", e, mediaItem);
IDisposable disposePlayer = player as IDisposable;
if (disposePlayer != null)
{
disposePlayer.Dispose();
}
return(false);
}
}
public void ExitModelContext(NavigationContext oldContext, NavigationContext newContext)
{
INotificationService notificationService = ServiceRegistration.Get <INotificationService>();
notificationService.CheckForTimeouts = true;
}
public void GoToNotification()
{
IWorkflowManager workflowManager = ServiceRegistration.Get <IWorkflowManager>();
workflowManager.NavigatePush(Consts.WF_STATE_ID_WATCH_NOTIFICATIONS);
}
/// <summary>
/// Returns all child directories of the given directory.
/// </summary>
/// <remarks>
/// This will return all native child directories of the given directory together with all virtual child
/// directories. The native child directories are taken directly from the given <paramref name="directoryAccessor"/>,
/// the virtual child directories are obtained by taking the root directories of each chained resource provider applied
/// to the child files of the given directory.
/// If, for example, the given <paramref name="directoryAccessor"/> contains a child directory "A" and a child
/// archive file "B" which can work as input for an installed archive provider, providing the root directory "C"
/// of that archive, this method will return the resource accessors for directories "A" and "C".
/// </remarks>
/// <param name="directoryAccessor">Directory resource accessor to get all child directories for.</param>
/// <param name="showSystemResources">If set to <c>true</c>, system resources like the virtual drives and directories of the
/// <see cref="IResourceMountingService"/> will also be returned, else removed from the result value.</param>
/// <returns>Collection of directory accessors for all native and virtual child directories or <c>null</c>,
/// if the given <paramref name="directoryAccessor"/> is not a <see cref="IFileSystemResourceAccessor"/> and
/// if there is no chained resource provider to unfold the given directory.</returns>
public static ICollection <IFileSystemResourceAccessor> GetChildDirectories(IFileSystemResourceAccessor directoryAccessor, bool showSystemResources)
{
IResourceMountingService resourceMountingService = ServiceRegistration.Get <IResourceMountingService>();
IFileSystemResourceAccessor chainedResourceAccesor; // Needed in multiple source locations, that's why we declare it here
ICollection <IFileSystemResourceAccessor> childDirectories = directoryAccessor.GetChildDirectories();
ICollection <IFileSystemResourceAccessor> result = new List <IFileSystemResourceAccessor>();
if (childDirectories != null)
{
// Directories are maybe filtered and then just added
foreach (IFileSystemResourceAccessor childDirectoryAccessor in childDirectories)
{
if (!showSystemResources && resourceMountingService.IsVirtualResource(childDirectoryAccessor.CanonicalLocalResourcePath))
{
childDirectoryAccessor.Dispose();
continue;
}
result.Add(childDirectoryAccessor);
}
}
ICollection <IFileSystemResourceAccessor> files = directoryAccessor.GetFiles();
if (files != null)
{
// For files, we try to chain up chained resource providers
foreach (IFileSystemResourceAccessor fileAccessor in files)
{
using (fileAccessor)
{
if (!showSystemResources && resourceMountingService.IsVirtualResource(fileAccessor.CanonicalLocalResourcePath))
{
continue;
}
if (TryUnfold(fileAccessor, out chainedResourceAccesor))
{
if (!chainedResourceAccesor.IsFile)
{
result.Add(chainedResourceAccesor);
}
else
{
chainedResourceAccesor.Dispose();
}
}
// Simply ignore files because we only want to return directories
}
}
}
if (result.Count > 0)
{
return(result);
}
// Try to unfold simple resource
if (TryUnfold(directoryAccessor, out chainedResourceAccesor))
{
if (!chainedResourceAccesor.IsFile)
{
return(new List <IFileSystemResourceAccessor>(new IFileSystemResourceAccessor[] { chainedResourceAccesor }));
}
chainedResourceAccesor.Dispose();
}
return(null);
}
/// <summary>
/// Unregisters the service with the specified name.
/// </summary>
/// <param name="serviceType">The type of service to be removed.</param>
/// <param name="key">
/// The name the object was registered with. Can be <see langword="null"/> or empty.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="serviceType"/> is <see langword="null"/>.
/// </exception>
public void Unregister(Type serviceType, string key)
{
ThrowIfDisposed();
if (serviceType == null)
throw new ArgumentNullException(nameof(serviceType));
var registration = new ServiceRegistration(serviceType, key);
lock (_registry)
{
ServiceEntry entry;
if (_registry.TryGetValue(registration, out entry))
{
DisposeInstances(entry);
_registry.Remove(registration);
}
}
}
public void Init()
{
ServiceRegistration.Set <ILocalization>(new NoLocalization());
}
public string GetModelURL(CultureInfo culture)
{
return(StringUtils.TrimToNull(ServiceRegistration.Get <ILocalization>().ToString(RES_MODEL_URL)));
}
public string GetModelDescription(CultureInfo culture)
{
return(StringUtils.TrimToNull(ServiceRegistration.Get <ILocalization>().ToString(RES_MODEL_DESCRIPTION)));
}
public string GetManufacturerURL(CultureInfo culture)
{
return(StringUtils.TrimToNull(ServiceRegistration.Get <ILocalization>().ToString(RES_MANUFACTURER_URL)));
}
protected bool TryMatch(string seriesNameOrImdbId, bool isImdbId, bool cacheOnly, out TvdbSeries seriesDetail, int tvdbid = 0)
{
seriesDetail = null;
try
{
// Prefer memory cache
CheckCacheAndRefresh();
if (_memoryCache.TryGetValue(seriesNameOrImdbId, out seriesDetail))
{
if (tvdbid == 0 || seriesDetail.Id == tvdbid)
{
return(true);
}
}
// Load cache or create new list
List <SeriesMatch> matches;
lock (_syncObj)
matches = Settings.Load <List <SeriesMatch> >(MatchesSettingsFile) ?? new List <SeriesMatch>();
// Init empty
seriesDetail = null;
// Use cached values before doing online query
SeriesMatch match = matches.Find(m =>
(
string.Equals(m.ItemName, seriesNameOrImdbId, StringComparison.OrdinalIgnoreCase) ||
string.Equals(m.TvDBName, seriesNameOrImdbId, StringComparison.OrdinalIgnoreCase)
) && (tvdbid == 0 || m.Id == tvdbid));
ServiceRegistration.Get <ILogger>().Debug("SeriesTvDbMatcher: Try to lookup series \"{0}\" from cache: {1}", seriesNameOrImdbId, match != null && match.Id != 0);
// Try online lookup
if (!Init())
{
return(false);
}
// If this is a known series, only return the series details (including episodes).
if (match != null)
{
return(match.Id != 0 && _tv.GetSeries(match.Id, true, out seriesDetail));
}
if (cacheOnly)
{
return(false);
}
TvdbSearchResult matchedSeries = null;
bool foundResult = false;
if (tvdbid != 0)
{
foundResult = _tv.GetSeries(tvdbid, true, out seriesDetail);
}
else
if (isImdbId)
{
// If we got an IMDBID, use it to lookup by key directly
_tv.GetSeries(seriesNameOrImdbId, out matchedSeries);
}
else
{
// Otherwise we try to find unique series by name
List <TvdbSearchResult> series;
if (_tv.SearchSeriesUnique(seriesNameOrImdbId, out series))
{
matchedSeries = series[0];
}
}
if (matchedSeries != null)
{
ServiceRegistration.Get <ILogger>().Debug("SeriesTvDbMatcher: Found unique online match for \"{0}\": \"{1}\" [Lang: {2}]", seriesNameOrImdbId, matchedSeries.SeriesName, matchedSeries.Language);
foundResult = _tv.GetSeries(matchedSeries.Id, true, out seriesDetail);
}
if (foundResult)
{
ServiceRegistration.Get <ILogger>().Debug("SeriesTvDbMatcher: Loaded details for \"{0}\"", seriesDetail.SeriesName);
// Add this match to cache
SeriesMatch onlineMatch = new SeriesMatch
{
ItemName = seriesNameOrImdbId,
Id = seriesDetail.Id,
TvDBName = seriesDetail.SeriesName
};
// Save cache
_storage.TryAddMatch(onlineMatch);
return(true);
}
ServiceRegistration.Get <ILogger>().Debug("SeriesTvDbMatcher: No unique match found for \"{0}\"", seriesNameOrImdbId);
// Also save "non matches" to avoid retrying
_storage.TryAddMatch(new SeriesMatch {
ItemName = seriesNameOrImdbId
});
return(false);
}
catch (Exception ex)
{
ServiceRegistration.Get <ILogger>().Debug("SeriesTvDbMatcher: Exception while processing series {0}", ex, seriesNameOrImdbId);
return(false);
}
finally
{
if (seriesDetail != null)
{
_memoryCache.TryAdd(seriesNameOrImdbId, seriesDetail);
}
}
}
public virtual Task <bool> TryExtractMetadataAsync(IResourceAccessor mediaItemAccessor, IDictionary <Guid, IList <MediaItemAspect> > extractedAspectData, bool forceQuickMode)
{
try
{
IResourceAccessor metaFileAccessor;
if (!CanExtract(mediaItemAccessor, extractedAspectData, out metaFileAccessor))
{
return(Task.FromResult(false));
}
Tags tags;
using (metaFileAccessor)
{
using (Stream metaStream = ((IFileSystemResourceAccessor)metaFileAccessor).OpenRead())
tags = (Tags)GetTagsXmlSerializer().Deserialize(metaStream);
}
//Assign all tags to the aspects for both tv and radio recordings
string value;
MediaItemAspect.SetAttribute(extractedAspectData, MediaAspect.ATTR_ISVIRTUAL, false);
if (TryGet(tags, TAG_TITLE, out value) && !string.IsNullOrEmpty(value))
{
if (value.Equals("manual", StringComparison.InvariantCultureIgnoreCase))
{
value = ResourcePathHelper.GetFileNameWithoutExtension(metaFileAccessor.Path);
}
MediaItemAspect.SetAttribute(extractedAspectData, MediaAspect.ATTR_TITLE, value);
MediaItemAspect.SetAttribute(extractedAspectData, MediaAspect.ATTR_SORT_TITLE, BaseInfo.GetSortTitle(value));
}
if (TryGet(tags, TAG_CHANNEL, out value))
{
MediaItemAspect.SetAttribute(extractedAspectData, RecordingAspect.ATTR_CHANNEL, value);
}
// Recording date formatted: 2011-11-04 20:55
DateTime tmpValue;
DateTime?recordingStart = null;
DateTime?recordingEnd = null;
DateTime?programStart = null;
DateTime?programEnd = null;
// First try to read program start and end times, they will be preferred.
if (TryGet(tags, TAG_PROGRAMSTARTTIME, out value) && DateTime.TryParse(value, out tmpValue))
{
programStart = tmpValue;
}
if (TryGet(tags, TAG_PROGRAMENDTIME, out value) && DateTime.TryParse(value, out tmpValue))
{
programEnd = tmpValue;
}
if (TryGet(tags, TAG_STARTTIME, out value) && DateTime.TryParse(value, out tmpValue))
{
recordingStart = tmpValue;
}
if (TryGet(tags, TAG_ENDTIME, out value) && DateTime.TryParse(value, out tmpValue))
{
recordingEnd = tmpValue;
}
// Correct start time if recording started before the program (skip pre-recording offset)
if (programStart.HasValue && recordingStart.HasValue && programStart > recordingStart)
{
recordingStart = programStart;
}
// Correct end time if recording ended after the program (skip the post-recording offset)
if (programEnd.HasValue && recordingEnd.HasValue && programEnd < recordingEnd)
{
recordingEnd = programEnd;
}
if (recordingStart.HasValue)
{
MediaItemAspect.SetAttribute(extractedAspectData, RecordingAspect.ATTR_STARTTIME, recordingStart.Value);
}
if (recordingEnd.HasValue)
{
MediaItemAspect.SetAttribute(extractedAspectData, RecordingAspect.ATTR_ENDTIME, recordingEnd.Value);
RecordingUtils.CheckAndPrepareAspectRefresh(extractedAspectData);
}
if (extractedAspectData.ContainsKey(VideoAspect.ASPECT_ID)) //Only add video information for actual video recordings
{
// Force MimeType
IList <MultipleMediaItemAspect> providerAspects;
MediaItemAspect.TryGetAspects(extractedAspectData, ProviderResourceAspect.Metadata, out providerAspects);
foreach (MultipleMediaItemAspect aspect in providerAspects)
{
aspect.SetAttribute(ProviderResourceAspect.ATTR_MIME_TYPE, "slimtv/video");
}
MediaItemAspect.SetAttribute(extractedAspectData, VideoAspect.ATTR_ISDVD, false);
if (TryGet(tags, TAG_PLOT, out value))
{
MediaItemAspect.SetAttribute(extractedAspectData, VideoAspect.ATTR_STORYPLOT, value);
Match yearMatch = _yearMatcher.Match(value);
int guessedYear;
if (int.TryParse(yearMatch.Value, out guessedYear))
{
MediaItemAspect.SetAttribute(extractedAspectData, MediaAspect.ATTR_RECORDINGTIME, new DateTime(guessedYear, 1, 1));
}
}
if (TryGet(tags, TAG_GENRE, out value) && !string.IsNullOrEmpty(value?.Trim()))
{
List <GenreInfo> genreList = new List <GenreInfo>(new GenreInfo[] { new GenreInfo {
Name = value.Trim()
} });
IGenreConverter converter = ServiceRegistration.Get <IGenreConverter>();
foreach (var genre in genreList)
{
if (!genre.Id.HasValue && converter.GetGenreId(genre.Name, GenreCategory.Movie, null, out int genreId))
{
genre.Id = genreId;
}
}
MultipleMediaItemAspect genreAspect = MediaItemAspect.CreateAspect(extractedAspectData, GenreAspect.Metadata);
genreAspect.SetAttribute(GenreAspect.ATTR_ID, genreList[0].Id);
genreAspect.SetAttribute(GenreAspect.ATTR_GENRE, genreList[0].Name);
}
}
else //Add comment for radio recordings
{
if (TryGet(tags, TAG_PLOT, out value))
{
MediaItemAspect.SetAttribute(extractedAspectData, MediaAspect.ATTR_COMMENT, value);
}
if (TryGet(tags, TAG_GENRE, out value) && !string.IsNullOrEmpty(value?.Trim()))
{
List <GenreInfo> genreList = new List <GenreInfo>(new GenreInfo[] { new GenreInfo {
Name = value.Trim()
} });
IGenreConverter converter = ServiceRegistration.Get <IGenreConverter>();
foreach (var genre in genreList)
{
if (!genre.Id.HasValue && converter.GetGenreId(genre.Name, GenreCategory.Music, null, out int genreId))
{
genre.Id = genreId;
}
}
MultipleMediaItemAspect genreAspect = MediaItemAspect.CreateAspect(extractedAspectData, GenreAspect.Metadata);
genreAspect.SetAttribute(GenreAspect.ATTR_ID, genreList[0].Id);
genreAspect.SetAttribute(GenreAspect.ATTR_GENRE, genreList[0].Name);
}
}
return(Task.FromResult(true));
}
catch (Exception e)
{
// Only log at the info level here - And simply return false. This lets the caller know that we
// couldn't perform our task here.
ServiceRegistration.Get <ILogger>().Info("Tve3RecordingMetadataExtractor: Exception reading resource '{0}' (Text: '{1}')", mediaItemAccessor.CanonicalLocalResourcePath, e.Message);
}
return(Task.FromResult(false));
}
public void ToString_WithNullProperty_ReturnsEasyToReadRepresentation()
{
var sr = new ServiceRegistration();
sr.ServiceType = typeof(IFoo);
sr.ServiceName = "AnotherFoo";
sr.ImplementingType = null;
var toString = sr.ToString();
Assert.Equal("ServiceType: 'LightInject.SampleLibrary.IFoo', ServiceName: 'AnotherFoo', ImplementingType: '', Lifetime: 'Transient'", toString);
}
/// <summary>
/// Adds the TsReader filter to the graph.
/// </summary>
protected override void AddSourceFilter()
{
// Render the file
_sourceFilter = FilterLoader.LoadFilterFromDll("TsReader.ax", typeof(TsReader).GUID, true);
IFileSourceFilter fileSourceFilter = (IFileSourceFilter)_sourceFilter;
ITsReader tsReader = (ITsReader)_sourceFilter;
tsReader.SetRelaxedMode(1);
tsReader.SetTsReaderCallback(this);
tsReader.SetRequestAudioChangeCallback(this);
_graphBuilder.AddFilter(_sourceFilter, TSREADER_FILTER_NAME);
_subtitleRenderer = new SubtitleRenderer(OnTextureInvalidated);
_subtitleFilter = _subtitleRenderer.AddSubtitleFilter(_graphBuilder);
if (_subtitleFilter != null)
{
_subtitleRenderer.RenderSubtitles = true;
_subtitleRenderer.SetPlayer(this);
}
if (_resourceLocator.NativeResourcePath.IsNetworkResource)
{
// _resourceAccessor points to an rtsp:// stream or network file
var sourcePathOrUrl = SourcePathOrUrl;
if (sourcePathOrUrl == null)
{
throw new IllegalCallException("The TsVideoPlayer can only play network resources of type INetworkResourceAccessor");
}
ServiceRegistration.Get <ILogger>().Debug("{0}: Initializing for stream '{1}'", PlayerTitle, sourcePathOrUrl);
IDisposable accessEnsurer = null;
if (IsLocalFilesystemResource)
{
accessEnsurer = ((ILocalFsResourceAccessor)_resourceAccessor).EnsureLocalFileSystemAccess();
}
using (accessEnsurer)
{
int hr = fileSourceFilter.Load(SourcePathOrUrl, null);
new HRESULT(hr).Throw();
}
}
else
{
// _resourceAccessor points to a local or remote mapped .ts file
_localFsRaHelper = new LocalFsResourceAccessorHelper(_resourceAccessor);
var localFileSystemResourceAccessor = _localFsRaHelper.LocalFsResourceAccessor;
if (localFileSystemResourceAccessor == null)
{
throw new IllegalCallException("The TsVideoPlayer can only play file resources of type ILocalFsResourceAccessor");
}
using (localFileSystemResourceAccessor.EnsureLocalFileSystemAccess())
{
ServiceRegistration.Get <ILogger>().Debug("{0}: Initializing for stream '{1}'", PlayerTitle, localFileSystemResourceAccessor.LocalFileSystemPath);
int hr = fileSourceFilter.Load(localFileSystemResourceAccessor.LocalFileSystemPath, null);
new HRESULT(hr).Throw();
}
}
// Init GraphRebuilder
_graphRebuilder = new GraphRebuilder(_graphBuilder, _sourceFilter, OnAfterGraphRebuild)
{
PlayerName = PlayerTitle
};
}
/// <summary>
/// Gets a list of <see cref="FanArtImage"/>s for a requested <paramref name="mediaType"/>, <paramref name="fanArtType"/> and <paramref name="name"/>.
/// The name can be: Series name, Actor name, Artist name depending on the <paramref name="mediaType"/>.
/// </summary>
/// <param name="mediaType">Requested FanArtMediaType</param>
/// <param name="fanArtType">Requested FanArtType</param>
/// <param name="name">Requested name of Series, Actor, Artist...</param>
/// <param name="maxWidth">Maximum width for image. <c>0</c> returns image in original size.</param>
/// <param name="maxHeight">Maximum height for image. <c>0</c> returns image in original size.</param>
/// <param name="singleRandom">If <c>true</c> only one random image URI will be returned</param>
/// <param name="result">Result if return code is <c>true</c>.</param>
/// <returns><c>true</c> if at least one match was found.</returns>
public bool TryGetFanArt(string mediaType, string fanArtType, string name, int maxWidth, int maxHeight, bool singleRandom, out IList <IResourceLocator> result)
{
result = null;
if (mediaType != FanArtMediaTypes.ChannelTv && mediaType != FanArtMediaTypes.ChannelRadio)
{
return(false);
}
try
{
string designsFolder = _designsFolder ?? FileUtils.BuildAssemblyRelativePath("Designs");
ChannelType logoChannelType = mediaType == FanArtMediaTypes.ChannelTv ? ChannelType.Tv : ChannelType.Radio;
ThemeHandler themeHandler = new ThemeHandler();
Theme theme = themeHandler.Load(Path.Combine(designsFolder, _settings.LogoTheme));
string logoFolder = Path.Combine(_dataFolder, string.Format("{0}-{1}-{2}", logoChannelType, theme.DesignName, theme.ThemeName));
string logoFileName = Path.Combine(logoFolder, FileUtils.GetSafeFilename(string.Format("{0}.png", name)));
if (!Directory.Exists(logoFolder))
{
Directory.CreateDirectory(logoFolder);
}
if (File.Exists(logoFileName) && IsCacheValid(theme, logoFileName))
{
return(BuildLogoResourceLocatorAndReturn(ref result, logoFileName));
}
LogoProcessor processor = new LogoProcessor {
DesignsFolder = designsFolder
};
// From repository
using (var repo = new LogoRepository {
RepositoryUrl = _settings.RepositoryUrl
})
{
var stream = repo.Download(name, logoChannelType, _country.TwoLetterISORegionName);
if (stream == null)
{
return(BuildLogoResourceLocatorAndReturn(ref result, logoFileName));
}
using (stream)
{
// First download and process the new logo, but keep the existing file if something fails.
string tmpLogoFileName = Path.ChangeExtension(logoFileName, ".tmplogo");
if (processor.CreateLogo(theme, stream, tmpLogoFileName))
{
if (File.Exists(logoFileName))
{
File.Delete(logoFileName);
}
File.Move(tmpLogoFileName, logoFileName);
}
return(BuildLogoResourceLocatorAndReturn(ref result, logoFileName));
}
}
}
catch (Exception ex)
{
ServiceRegistration.Get <ILogger>().Error("SlimTv Logos: Error processing logo image.", ex);
}
return(false);
}
/// <summary>
/// Loads the plugin descriptor file (plugin.xml) from a plugin directory.
/// </summary>
/// <param name="pluginDirectoryPath">Root directory path of the plugin to load the metadata.</param>
/// <returns><c>true</c>, if the plugin descriptor could successfully be loaded, else <c>false</c>.
/// </returns>
protected bool Load(string pluginDirectoryPath)
{
string path = Path.Combine(pluginDirectoryPath, PLUGIN_META_FILE);
if (!File.Exists(path))
return false;
_pluginFilePath = path;
try
{
using (Stream pluginFileStream = File.OpenRead(_pluginFilePath))
{
XPathDocument doc = new XPathDocument(pluginFileStream);
XPathNavigator nav = doc.CreateNavigator();
nav.MoveToChild(XPathNodeType.Element);
if (nav.LocalName != "Plugin")
throw new ArgumentException(
"File is no plugin descriptor file (document element must be 'Plugin')");
bool versionOk = false;
bool pluginIdSet = false;
XPathNavigator attrNav = nav.Clone();
if (attrNav.MoveToFirstAttribute())
do
{
switch (attrNav.Name)
{
case "DescriptorVersion":
Versions.CheckVersionCompatible(attrNav.Value, PLUGIN_DESCRIPTOR_VERSION_MAJOR, MIN_PLUGIN_DESCRIPTOR_VERSION_MINOR);
//string specVersion = attr.Value; <- if needed
versionOk = true;
break;
case "Name":
_name = attrNav.Value;
break;
case "PluginId":
_pluginId = new Guid(attrNav.Value);
pluginIdSet = true;
break;
case "Author":
_author = attrNav.Value;
break;
case "Copyright":
_copyright = attrNav.Value;
break;
case "Description":
_description = attrNav.Value;
break;
case "AutoActivate":
_autoActivate = Boolean.Parse(attrNav.Value);
break;
default:
throw new ArgumentException("'Plugin' element doesn't support an attribute '" + attrNav.Name + "'");
}
} while (attrNav.MoveToNextAttribute());
if (!versionOk)
throw new ArgumentException("'Version' attribute not found");
if (!pluginIdSet)
throw new ArgumentException("'PluginId' attribute not found");
XPathNavigator childNav = nav.Clone();
if (childNav.MoveToChild(XPathNodeType.Element))
do
{
switch (childNav.LocalName)
{
case "Version":
ParseVersionElement(childNav.Clone());
break;
case "Runtime":
ParseRuntimeElement(childNav.Clone(), pluginDirectoryPath);
break;
case "Builder":
if (_builders == null)
_builders = new Dictionary<string, string>();
_builders.Add(ParseBuilderElement(childNav.Clone()));
break;
case "Register":
CollectionUtils.AddAll(_itemsMetadata, ParseRegisterElement(childNav.Clone()));
break;
case "DependsOn":
CollectionUtils.AddAll(_dependsOn, ParsePluginDependencies(childNav.Clone()));
break;
case "ConflictsWith":
CollectionUtils.AddAll(_conflictsWith, ParsePluginIdEnumeration(childNav.Clone()));
break;
default:
throw new ArgumentException("'Plugin' element doesn't support a child element '" + childNav.Name + "'");
}
} while (childNav.MoveToNext(XPathNodeType.Element));
}
}
catch (Exception e)
{
ServiceRegistration.Get<ILogger>().Error("Error parsing plugin descriptor file '" + _pluginFilePath + "'", e);
return false;
}
return true;
}
private Task <bool> ExtractThumbnailAsync(ILocalFsResourceAccessor lfsra, IDictionary <Guid, IList <MediaItemAspect> > extractedAspectData)
{
// We can only work on files and make sure this file was detected by a lower MDE before (title is set then).
// VideoAspect must be present to be sure it is actually a video resource.
if (!lfsra.IsFile || !extractedAspectData.ContainsKey(VideoStreamAspect.ASPECT_ID))
{
return(Task.FromResult(false));
}
//ServiceRegistration.Get<ILogger>().Info("OCVVideoThumbnailer: Evaluate {0}", lfsra.ResourceName);
bool isPrimaryResource = false;
IList <MultipleMediaItemAspect> resourceAspects;
if (MediaItemAspect.TryGetAspects(extractedAspectData, ProviderResourceAspect.Metadata, out resourceAspects))
{
foreach (MultipleMediaItemAspect pra in resourceAspects)
{
string accessorPath = (string)pra.GetAttributeValue(ProviderResourceAspect.ATTR_RESOURCE_ACCESSOR_PATH);
ResourcePath resourcePath = ResourcePath.Deserialize(accessorPath);
if (resourcePath.Equals(lfsra.CanonicalLocalResourcePath))
{
if (pra.GetAttributeValue <int?>(ProviderResourceAspect.ATTR_TYPE) == ProviderResourceAspect.TYPE_PRIMARY)
{
isPrimaryResource = true;
break;
}
}
}
}
if (!isPrimaryResource) //Ignore subtitles
{
return(Task.FromResult(false));
}
// Check for a reasonable time offset
int defaultVideoOffset = 720;
long videoDuration;
double downscale = 2; // Reduces the video frame size to a half of original
IList <MultipleMediaItemAspect> videoAspects;
if (MediaItemAspect.TryGetAspects(extractedAspectData, VideoStreamAspect.Metadata, out videoAspects))
{
if ((videoDuration = videoAspects[0].GetAttributeValue <long>(VideoStreamAspect.ATTR_DURATION)) > 0)
{
if (defaultVideoOffset > videoDuration * 1 / 3)
{
defaultVideoOffset = Convert.ToInt32(videoDuration * 1 / 3);
}
}
double width = videoAspects[0].GetAttributeValue <int>(VideoStreamAspect.ATTR_WIDTH);
double height = videoAspects[0].GetAttributeValue <int>(VideoStreamAspect.ATTR_HEIGHT);
downscale = width / 256.0; //256 is max size of large thumbnail aspect
}
using (lfsra.EnsureLocalFileSystemAccess())
{
using (VideoCapture capture = new VideoCapture())
{
capture.Open(lfsra.LocalFileSystemPath);
capture.PosMsec = defaultVideoOffset * 1000;
using (var mat = capture.RetrieveMat())
{
if (mat.Height > 0 && mat.Width > 0)
{
double width = mat.Width;
double height = mat.Height;
ServiceRegistration.Get <ILogger>().Debug("OCVVideoThumbnailer: Scaling thumbnail of size {1}x{2} for resource '{0}'", lfsra.LocalFileSystemPath, width, height);
using (var scaledMat = mat.Resize(new OpenCvSharp.Size(width / downscale, height / downscale)))
{
var binary = scaledMat.ToBytes();
MediaItemAspect.SetAttribute(extractedAspectData, ThumbnailLargeAspect.ATTR_THUMBNAIL, binary);
ServiceRegistration.Get <ILogger>().Info("OCVVideoThumbnailer: Successfully created thumbnail for resource '{0}'", lfsra.LocalFileSystemPath);
}
}
else
{
ServiceRegistration.Get <ILogger>().Warn("OCVVideoThumbnailer: Failed to create thumbnail for resource '{0}'", lfsra.LocalFileSystemPath);
}
}
}
}
return(Task.FromResult(true));
}
/// <summary>
/// Dequeues the current notification and makes the next notification available.
/// </summary>
public void DequeueNotification()
{
INotificationService notificationService = ServiceRegistration.Get <INotificationService>();
notificationService.DequeueNotification();
}
public void OnTsPacket(byte[] tsPacket, UInt64 presentTime)
{
// ServiceRegistration.Get<ILogger>().Debug("PESDECODER ONTSPACKET");
TSHeader header = new TSHeader(tsPacket);
if (!SanityCheck(header, tsPacket))
{
return;
}
int pos = header.PayLoadStart; // where in the pes packet does the payload data start?
if (header.PayloadUnitStart) // if this header starts a new PES packet
{
//ServiceRegistration.Get<ILogger>().Debug("PESDECODER: PayLoadUnitStart");
_hasPayloadStart = true;
if (tsPacket[pos + 0] == 0 && tsPacket[pos + 1] == 0 && tsPacket[pos + 2] == 1)
{
if (_iStreamId < 0)
{
//if stream id not set yet, get it from this
_iStreamId = tsPacket[pos + 3];
if (_iStreamId < 0)
{
throw new Exception("Stream id less than zero :" + _iStreamId);
}
}
else
{
Assert(_iStreamId == tsPacket[pos + 3], "Stream id changed!"); // stream id should not change!
}
if (_iWritePos != 0)
{
//throw new Exception("Buffer is not empty, but new packet is being received!");
ServiceRegistration.Get <ILogger>().Warn("PESDECODER: Buffer is not empty, but new packet is being received!");
}
_iWritePos = 0;
_iPesHeaderLen = tsPacket[pos + 8] + 9;
if (_pesHeader.Length < _iPesHeaderLen)
{
ServiceRegistration.Get <ILogger>().Error(
"PESDecoder: Reported header length is bigger than header buffer! : {0} vs {1}", _pesHeader.Length,
_iPesHeaderLen);
}
Array.Copy(tsPacket, pos, _pesHeader, 0, _iPesHeaderLen);
//above replaces -> memcpy(m_pesHeader,&tsPacket[pos],m_iPesHeaderLen);
pos += (_iPesHeaderLen);
_bStart = true;
int a = _pesHeader[4];
int b = _pesHeader[5];
_iPesLength = (a << 8) + b - (_iPesHeaderLen - 6); // calculate expected actual payload length
}
}
else if (!_hasPayloadStart)
{
//ServiceRegistration.Get<ILogger>().Debug("PACKET DISCARDED: END OF PACKET FOR WHICH WE DONT HAVE START");
return;
}
if (_iWritePos < 0)
{
ServiceRegistration.Get <ILogger>().Debug("m_iWritePos < 0");
return;
}
if (_iStreamId <= 0)
{
ServiceRegistration.Get <ILogger>().Debug("m_iStreamId <= 0");
return;
}
Assert(pos > 0 && pos < 188, "Pos error : " + pos);
Assert(_iWritePos + 188 - pos <= MAX_PES_PACKET, "About to exceed buffer size!");
// check that the buffer is not overrunning
int bytesToWrite = 188 - pos;
Assert(bytesToWrite < 188, "Bytes to write too big : " + bytesToWrite);
Array.Copy(tsPacket, pos, _pesBuffer, _iWritePos, bytesToWrite);
_iWritePos += bytesToWrite;
if (_iPesLength == _iWritePos) // we have the expected data
{
// ServiceRegistration.Get<ILogger>().Debug("PESDECODER: GOT COMPLETE PACKET");
// assert(cb != null, "cb is null!");
if (_iWritePos > 0 && _cb != null)
{
//ServiceRegistration.Get<ILogger>().Debug("PESDECODER: CALLING CALLBACK");
_cb(_iStreamId, _pesHeader, _iPesHeaderLen, _pesBuffer, _iWritePos, _bStart, presentTime);
_bStart = false;
_iWritePos = 0;
_hasPayloadStart = false;
}
}
}
public bool CanEnterState(NavigationContext oldContext, NavigationContext newContext)
{
INotificationService notificationService = ServiceRegistration.Get <INotificationService>();
return(notificationService.Notifications.Count > 0);
}
private static ServiceRegistration CreateConsulAgentRegistration(this IConveyBuilder builder,
ConsulOptions options)
{
var enabled = options.Enabled;
var consulEnabled = Environment.GetEnvironmentVariable("CONSUL_ENABLED")?.ToLowerInvariant();
if (!string.IsNullOrWhiteSpace(consulEnabled))
{
enabled = consulEnabled == "true" || consulEnabled == "1";
}
if (!enabled)
{
return(null);
}
if (string.IsNullOrWhiteSpace(options.Address))
{
throw new ArgumentException("Consul address can not be empty.",
nameof(options.PingEndpoint));
}
builder.Services.AddHttpClient <IConsulService, ConsulService>(c => c.BaseAddress = new Uri(options.Url));
if (builder.Services.All(x => x.ServiceType != typeof(ConsulHostedService)))
{
builder.Services.AddHostedService <ConsulHostedService>();
}
var serviceId = string.Empty;
using (var serviceProvider = builder.Services.BuildServiceProvider())
{
serviceId = serviceProvider.GetRequiredService <IServiceId>().Id;
}
var registration = new ServiceRegistration
{
Name = options.Service,
Id = $"{options.Service}:{serviceId}",
Address = options.Address,
Port = options.Port,
Tags = options.Tags,
Meta = options.Meta,
EnableTagOverride = options.EnableTagOverride,
Connect = options.Connect?.Enabled == true ? new Connect() : null
};
if (!options.PingEnabled)
{
return(registration);
}
var pingEndpoint = string.IsNullOrWhiteSpace(options.PingEndpoint) ? string.Empty :
options.PingEndpoint.StartsWith("/") ? options.PingEndpoint : $"/{options.PingEndpoint}";
if (pingEndpoint.EndsWith("/"))
{
pingEndpoint = pingEndpoint.Substring(0, pingEndpoint.Length - 1);
}
var scheme = options.Address.StartsWith("http", StringComparison.InvariantCultureIgnoreCase)
? string.Empty
: "http://";
var check = new ServiceCheck
{
Interval = ParseTime(options.PingInterval),
DeregisterCriticalServiceAfter = ParseTime(options.RemoveAfterInterval),
Http = $"{scheme}{options.Address}{(options.Port > 0 ? $":{options.Port}" : string.Empty)}" +
$"{pingEndpoint}"
};
registration.Checks = new[] { check };
return(registration);
}
protected void Update()
{
ISystemStateService sss = ServiceRegistration.Get <ISystemStateService>();
if (sss.CurrentState != SystemState.Running)
{
return;
}
INotificationService notificationService = ServiceRegistration.Get <INotificationService>();
int numNotifications = notificationService.Notifications.Count;
IWorkflowManager workflowManager = ServiceRegistration.Get <IWorkflowManager>();
if (numNotifications == 0 && workflowManager.CurrentNavigationContext.WorkflowState.StateId == Consts.WF_STATE_ID_WATCH_NOTIFICATIONS)
{
// Don't pop the watch-notifications state from the navigation stack if we are in a sub state
workflowManager.NavigatePopToStateAsync(Consts.WF_STATE_ID_WATCH_NOTIFICATIONS, true);
}
IsNotificationsHintVisible = !workflowManager.IsStateContainedInNavigationStack(Consts.WF_STATE_ID_WATCH_NOTIFICATIONS) && numNotifications > 0;
NumNotificationsTotal = numNotifications;
IsNotificationsAvailable = numNotifications > 0;
IsMoreThanOneNotificationAvailable = numNotifications > 1;
if (numNotifications <= 1)
{
NMoreNotificationsText = string.Empty;
}
else if (numNotifications == 2)
{
NMoreNotificationsText = LocalizationHelper.Translate(Consts.RES_ONE_MORE_NOTIFICATION);
}
else
{
NMoreNotificationsText = LocalizationHelper.Translate(Consts.RES_N_MORE_NOTIFICATIONS, numNotifications - 1);
}
INotification notification = notificationService.PeekNotification();
CurrentNotification = notification;
if (notification != null)
{
if (string.IsNullOrEmpty(notification.CustomIconPath))
{
switch (notification.Type)
{
case NotificationType.UserInteractionRequired:
NotificationSymbolRelFilePath = Consts.REL_PATH_USER_INTERACTION_REQUIRED_ICON;
break;
case NotificationType.Info:
NotificationSymbolRelFilePath = Consts.REL_PATH_INFO_ICON;
break;
case NotificationType.Warning:
NotificationSymbolRelFilePath = Consts.REL_PATH_WARNING_ICON;
break;
case NotificationType.Error:
NotificationSymbolRelFilePath = Consts.REL_PATH_ERROR_ICON;
break;
}
}
else
{
NotificationSymbolRelFilePath = notification.CustomIconPath;
}
HasSubWorkflow = notification.HandlerWorkflowState.HasValue;
}
}
public SystemResolver()
{
ServiceRegistration.Get <ILogger>().Info("SystemResolver: Local system id is '{0}'", _localSystemId);
}
public void Init()
{
ServiceRegistration.Set <IPathManager>(new PathManager());
ServiceRegistration.Set <ISettingsManager>(new NoSettingsManager());
ServiceRegistration.Set <ILocalization>(new NoLocalization());
}
protected void ShowServerNotConnectedDialog()
{
IDialogManager dialogManager = ServiceRegistration.Get <IDialogManager>();
dialogManager.ShowDialog(Consts.RES_SERVER_NOT_CONNECTED_DIALOG_HEADER, Consts.RES_SERVER_NOT_CONNECTED_DIALOG_TEXT, DialogType.OkDialog, false, null);
}
/// <summary>
/// Checks if our "currently playing" and "fullscreen content" states still fit to the
/// appropriate players, i.e. if we are in a "currently playing" state and the current player context was
/// changed, the workflow state will be adapted to match the new current player context's "currently playing" state.
/// The same check will happen for the primary player context and the "fullscreen content" state.
/// </summary>
/// <remarks>
/// This method must not be called when the player manager's lock is held.
/// </remarks>
protected void CheckMediaWorkflowStates_NoLock()
{
ISystemStateService sss = ServiceRegistration.Get <ISystemStateService>();
if (sss.CurrentState != SystemState.Running)
{
// Only automatically change workflow states in running state
return;
}
IWorkflowManager workflowManager = ServiceRegistration.Get <IWorkflowManager>();
workflowManager.StartBatchUpdateAsync();
ILogger log = ServiceRegistration.Get <ILogger>();
IPlayerManager playerManager = ServiceRegistration.Get <IPlayerManager>();
try
{
for (int i = 0; i < _playerWfStateInstances.Count; i++)
{
// Find the first workflow state of our cached player workflow states which doesn't fit any more
// and update to the new player workflow state of the same player workflow state type, if necessary.
PlayerWFStateInstance wfStateInstance = _playerWfStateInstances[i];
Guid? newStateId;
string stateName;
switch (wfStateInstance.WFStateType)
{
case PlayerWFStateType.CurrentlyPlaying:
newStateId = GetPotentialCPStateId();
stateName = "Currently Playing";
break;
case PlayerWFStateType.FullscreenContent:
newStateId = GetPotentialFSCStateId();
stateName = "Fullscreen Content";
break;
default:
throw new NotImplementedException(string.Format("No handler for player workflow state type '{0}'",
wfStateInstance.WFStateType));
}
if (newStateId != wfStateInstance.WFStateId)
{
// Found the first player workflow state which doesn't fit any more
log.Debug("PlayerContextManager: {0} Workflow State '{1}' doesn't fit any more to the current situation. Leaving workflow state.",
stateName, wfStateInstance.WFStateId);
lock (playerManager.SyncObj)
// Remove all workflow states until the player workflow state which doesn't fit any more
_playerWfStateInstances.RemoveRange(i, _playerWfStateInstances.Count - i);
workflowManager.NavigatePopToStateAsync(wfStateInstance.WFStateId, true);
if (newStateId.HasValue)
{
log.Debug("PlayerContextManager: Auto-switching to new {0} Workflow State '{1}'",
stateName, newStateId.Value);
workflowManager.NavigatePushAsync(newStateId.Value);
}
break;
}
}
}
finally
{
workflowManager.EndBatchUpdateAsync();
}
}
protected void LeavePartyMode()
{
IWorkflowManager workflowManager = ServiceRegistration.Get <IWorkflowManager>();
workflowManager.NavigatePopToStateAsync(Consts.WF_STATE_ID_PARTY_MUSIC_PLAYER, true);
}
public void ToString_WithLifetime_ReturnsEasyToReadRepresentation()
{
var sr = new ServiceRegistration();
sr.ServiceType = typeof(IFoo);
sr.ServiceName = "AnotherFoo";
sr.Lifetime = new PerContainerLifetime();
var toString = sr.ToString();
Assert.Equal("ServiceType: 'LightInject.SampleLibrary.IFoo', ServiceName: 'AnotherFoo', ImplementingType: '', Lifetime: 'LightInject.PerContainerLifetime'", toString);
}
public void GetInstance_ReadOnlyRegistration_ReturnsOriginalRegistration()
{
var container = CreateContainer();
var registration = new ServiceRegistration();
registration.ServiceType = typeof (IFoo);
registration.ServiceName = "";
registration.ImplementingType = typeof (Foo);
registration.IsReadOnly = true;
container.Register(registration);
container.Register<IFoo, AnotherFoo>();
var instance = container.GetInstance<IFoo>();
Assert.IsType(typeof (Foo), instance);
}
public object Any(ServiceRegistration registration)
{
return Discovery.Registration;
}
public static void SendPluginManagerMessage(MessageType messageType)
{
SystemMessage msg = new SystemMessage(messageType);
ServiceRegistration.Get <IMessageBroker>().Send(CHANNEL, msg);
}
public static void SendNavigationCompleteMessage()
{
SystemMessage msg = new SystemMessage(MessageType.NavigationComplete);
ServiceRegistration.Get <IMessageBroker>().Send(CHANNEL, msg);
}
private object GetInstanceImpl(Type serviceType, string key, bool onlyShared = false)
{
lock (_registry)
{
// Try to locate matching service entry in the current or a parent container.
ServiceRegistration registration = new ServiceRegistration(serviceType, key);
ServiceEntry entry;
ServiceContainer container;
if (_registry.TryGetValue(registration, out entry))
{
// Service entry found in local registry.
container = this;
}
else
{
// Check parent containers.
container = _parent;
while (container != null)
{
lock (container._registry)
{
if (container._registry.TryGetValue(registration, out entry))
break;
}
container = container._parent;
}
}
if (entry != null)
{
// Resolve instance from service entry.
if (entry.CreationPolicy == CreationPolicy.NonShared)
{
if (onlyShared)
return null;
// Create non-shared (transient) service instance.
var instance = entry.CreateInstance(this);
// Track for disposal, if necessary.
StoreInstance(entry, instance);
return instance;
}
if (entry.CreationPolicy == CreationPolicy.LocalShared && container != this)
{
// Service entry was found in a parent container, but the service is
// configured to be created per container. --> Copy into local registry.
entry = new ServiceEntry(entry);
_registry.Add(registration, entry);
container = this;
}
// Create shared service instance, if not already cached.
// (Double-check to avoid unnecessary lock.)
if (entry.Instances == null)
{
lock (entry)
{
if (entry.Instances == null)
{
var instance = entry.CreateInstance(container);
StoreInstance(entry, instance);
}
}
}
return entry.Instances;
}
}
// The requested service type is not directly registered.
// Other supported types are:
// - IEnumerable<TService> ... service instance collection
// - Func<TService> .......... factory method for lazy resolution
#if !NETFX_CORE && !NET45
if (serviceType.IsGenericType)
#else
if (serviceType.GetTypeInfo().IsGenericType)
#endif
{
var genericType = serviceType.GetGenericTypeDefinition();
if (genericType == typeof(IEnumerable<>))
{
// Requested type is IEnumerable<TService>.
// Get typeof(TService).
#if !NETFX_CORE && !NET45
Type actualServiceType = serviceType.GetGenericArguments()[0];
#else
Type actualServiceType = serviceType.GetTypeInfo().GenericTypeArguments[0];
#endif
// Get array of all named TService instances.
object[] instances = GetAllInstancesImpl(actualServiceType).ToArray();
// Create and fill TService[] array.
Array array = Array.CreateInstance(actualServiceType, instances.Length);
for (int i = 0; i < array.Length; i++)
array.SetValue(instances[i], i);
return array;
}
if (genericType == typeof(Func<>))
{
// Requested type is Func<TService>.
#if !NETFX_CORE && !NET45
var actualServiceType = serviceType.GetGenericArguments()[0];
var factoryFactoryType = typeof(ServiceFactoryFactory<>).MakeGenericType(actualServiceType);
var factoryFactoryInstance = Activator.CreateInstance(factoryFactoryType);
var factoryFactoryMethod = factoryFactoryType.GetMethod("Create");
#else
var actualServiceType = serviceType.GetTypeInfo().GenericTypeArguments[0];
var factoryFactoryType = typeof(ServiceFactoryFactory<>).MakeGenericType(actualServiceType);
var factoryFactoryInstance = Activator.CreateInstance(factoryFactoryType);
var factoryFactoryMethod = factoryFactoryType.GetTypeInfo().GetDeclaredMethod("Create");
#endif
return factoryFactoryMethod.Invoke(factoryFactoryInstance, new object[] { this, key });
}
//if (genericType == typeof(Func<,>) && serviceType.GetGenericArguments()[0] == typeof(string))
//{
// // Requested type is Func<string, TService> where the argument is the name of the service.
// ...
//}
}
return null;
}
/// <summary>
/// Registers the servicestack apphost with the local consul agent
/// </summary>
/// <exception cref="GatewayServiceDiscoveryException">throws exception if registration was not successful</exception>
public static void RegisterService(ServiceRegistration registration)
{
var consulServiceRegistration = new ConsulServiceRegistration(registration.Id, registration.Name)
{
Address = registration.Address,
Tags = registration.Tags,
Port = registration.Port
};
ServiceValidator.ValidateAndThrow(consulServiceRegistration);
var registrationUrl = ConsulUris.LocalAgent.CombineWith(consulServiceRegistration.ToPutUrl());
registrationUrl.PostJsonToUrl(consulServiceRegistration, null,
response =>
{
var logger = LogManager.GetLogger(typeof(ConsulClient));
if (response.StatusCode.IsErrorResponse())
{
logger.Fatal(
$"Could not register appHost with Consul. It will not be discoverable: {consulServiceRegistration}");
throw new GatewayServiceDiscoveryException("Failed to register service with consul");
}
else
{
logger.Info($"Registered service with Consul {consulServiceRegistration}");
AppDomain.CurrentDomain.ProcessExit +=
(sender, args) => UnregisterService(consulServiceRegistration.ID);
AppDomain.CurrentDomain.UnhandledException +=
(sender, args) => UnregisterService(consulServiceRegistration.ID);
}
});
}
/// <summary>
/// Adds a source filter to the graph and sets the input.
/// </summary>
protected override void AddSourceFilter()
{
if (!_useTsReader)
{
base.AddSourceFilter();
return;
}
// Render the file
// Notes Morpheus_xx, 2017-04-19:
// In contrast to TV we need to use a relative path here, as the method is located inside the SlimTV assembly.
// For TV part, the base class inside VideoPlayers is used and thus the correct path to TsReader.ax
// The problem with different paths appears only inside RELEASE builds, but not DEBUG. Why this happens I don't know.
_sourceFilter = FilterLoader.LoadFilterFromDll("..\\VideoPlayers\\TsReader.ax", typeof(TsReader).GUID, true);
var baseFilter = _sourceFilter.GetFilter();
IFileSourceFilter fileSourceFilter = (IFileSourceFilter)baseFilter;
_tsReader = (ITsReader)baseFilter;
_tsReader.SetRelaxedMode(1);
_tsReader.SetTsReaderCallback(this);
_tsReader.SetRequestAudioChangeCallback(this);
_graphBuilder.AddFilter(baseFilter, TSREADER_FILTER_NAME);
if (_resourceLocator.NativeResourcePath.IsNetworkResource)
{
// _resourceAccessor points to an rtsp:// stream or network file
var sourcePathOrUrl = SourcePathOrUrl;
if (sourcePathOrUrl == null)
{
throw new IllegalCallException("The LiveRadioPlayer can only play network resources of type INetworkResourceAccessor");
}
ServiceRegistration.Get <ILogger>().Debug("{0}: Initializing for stream '{1}'", PlayerTitle, sourcePathOrUrl);
IDisposable accessEnsurer = null;
if (IsLocalFilesystemResource)
{
accessEnsurer = ((ILocalFsResourceAccessor)_resourceAccessor).EnsureLocalFileSystemAccess();
}
using (accessEnsurer)
{
int hr = fileSourceFilter.Load(SourcePathOrUrl, null);
new HRESULT(hr).Throw();
}
}
else
{
//_resourceAccessor points to a local .ts file
var localFileSystemResourceAccessor = _resourceAccessor as ILocalFsResourceAccessor;
if (localFileSystemResourceAccessor == null)
{
throw new IllegalCallException("The LiveRadioPlayer can only play file resources of type ILocalFsResourceAccessor");
}
using (localFileSystemResourceAccessor.EnsureLocalFileSystemAccess())
{
ServiceRegistration.Get <ILogger>().Debug("{0}: Initializing for stream '{1}'", PlayerTitle, localFileSystemResourceAccessor.LocalFileSystemPath);
fileSourceFilter.Load(localFileSystemResourceAccessor.LocalFileSystemPath, null);
}
}
}
/// <summary>
/// Gets a list of <see cref="FanArtImage"/>s for a requested <paramref name="mediaType"/>, <paramref name="fanArtType"/> and <paramref name="name"/>.
/// The name can be: Series name, Actor name, Artist name depending on the <paramref name="mediaType"/>.
/// </summary>
/// <param name="mediaType">Requested FanArtMediaType</param>
/// <param name="fanArtType">Requested FanArtType</param>
/// <param name="name">Requested name of Series, Actor, Artist...</param>
/// <param name="maxWidth">Maximum width for image. <c>0</c> returns image in original size.</param>
/// <param name="maxHeight">Maximum height for image. <c>0</c> returns image in original size.</param>
/// <param name="singleRandom">If <c>true</c> only one random image URI will be returned</param>
/// <param name="result">Result if return code is <c>true</c>.</param>
/// <returns><c>true</c> if at least one match was found.</returns>
public bool TryGetFanArt(string mediaType, string fanArtType, string name, int maxWidth, int maxHeight, bool singleRandom, out IList <IResourceLocator> result)
{
result = null;
Guid mediaItemId;
if (mediaType != FanArtMediaTypes.Series && mediaType != FanArtMediaTypes.Episode)
{
return(false);
}
// Don't try to load "fanart" for images
if (!Guid.TryParse(name, out mediaItemId) || mediaType == FanArtMediaTypes.Image)
{
return(false);
}
IMediaLibrary mediaLibrary = ServiceRegistration.Get <IMediaLibrary>(false);
if (mediaLibrary == null)
{
return(false);
}
IFilter filter = null;
if (mediaType == FanArtMediaTypes.Series)
{
filter = new RelationshipFilter(EpisodeAspect.ROLE_EPISODE, SeriesAspect.ROLE_SERIES, mediaItemId);
}
else if (mediaType == FanArtMediaTypes.Episode)
{
filter = new MediaItemIdFilter(mediaItemId);
}
MediaItemQuery episodeQuery = new MediaItemQuery(NECESSARY_MIAS, filter);
episodeQuery.Limit = 1;
IList <MediaItem> items = mediaLibrary.Search(episodeQuery, false, null, false);
if (items == null || items.Count == 0)
{
return(false);
}
MediaItem mediaItem = items.First();
// Virtual resources won't have any local fanart
if (mediaItem.IsVirtual)
{
return(false);
}
var mediaIteamLocator = mediaItem.GetResourceLocator();
var fanArtPaths = new List <ResourcePath>();
var files = new List <IResourceLocator>();
// File based access
try
{
var mediaItemPath = mediaIteamLocator.NativeResourcePath;
var mediaItemDirectoryPath = ResourcePathHelper.Combine(mediaItemPath, "../../");
var mediaItemFileNameWithoutExtension = ResourcePathHelper.GetFileNameWithoutExtension(mediaItemPath.ToString()).ToLowerInvariant();
var mediaItemExtension = ResourcePathHelper.GetExtension(mediaItemPath.ToString());
using (var directoryRa = new ResourceLocator(mediaIteamLocator.NativeSystemId, mediaItemDirectoryPath).CreateAccessor())
{
var directoryFsra = directoryRa as IFileSystemResourceAccessor;
if (directoryFsra != null)
{
var potentialFanArtFiles = LocalFanartHelper.GetPotentialFanArtFiles(directoryFsra);
if (fanArtType == FanArtTypes.Thumbnail)
{
fanArtPaths.AddRange(LocalFanartHelper.FilterPotentialFanArtFilesByName(potentialFanArtFiles, LocalFanartHelper.THUMB_FILENAMES));
}
if (fanArtType == FanArtTypes.Poster)
{
fanArtPaths.AddRange(LocalFanartHelper.FilterPotentialFanArtFilesByName(potentialFanArtFiles, LocalFanartHelper.POSTER_FILENAMES));
}
if (fanArtType == FanArtTypes.Banner)
{
fanArtPaths.AddRange(LocalFanartHelper.FilterPotentialFanArtFilesByName(potentialFanArtFiles, LocalFanartHelper.BANNER_FILENAMES));
}
if (fanArtType == FanArtTypes.Logo)
{
fanArtPaths.AddRange(LocalFanartHelper.FilterPotentialFanArtFilesByName(potentialFanArtFiles, LocalFanartHelper.LOGO_FILENAMES));
}
if (fanArtType == FanArtTypes.ClearArt)
{
fanArtPaths.AddRange(LocalFanartHelper.FilterPotentialFanArtFilesByName(potentialFanArtFiles, LocalFanartHelper.CLEARART_FILENAMES));
}
if (fanArtType == FanArtTypes.FanArt)
{
fanArtPaths.AddRange(LocalFanartHelper.FilterPotentialFanArtFilesByPrefix(potentialFanArtFiles, LocalFanartHelper.BACKDROP_FILENAMES));
if (directoryFsra.ResourceExists("ExtraFanArt/"))
{
using (var extraFanArtDirectoryFsra = directoryFsra.GetResource("ExtraFanArt/"))
fanArtPaths.AddRange(LocalFanartHelper.GetPotentialFanArtFiles(extraFanArtDirectoryFsra));
}
}
files.AddRange(fanArtPaths.Select(path => new ResourceLocator(mediaIteamLocator.NativeSystemId, path)));
}
}
}
catch (Exception ex)
{
#if DEBUG
ServiceRegistration.Get <ILogger>().Warn("LocalSeriesFanArtProvider: Error while searching fanart of type '{0}' for '{1}'", ex, fanArtType, mediaIteamLocator);
#endif
}
result = files;
return(files.Count > 0);
}
/// <overloads>
/// <summary>
/// Registers a service.
/// </summary>
/// </overloads>
///
/// <summary>
/// Registers a service using a custom factory method and certain creation and disposal
/// policies.
/// </summary>
/// <param name="serviceType">The type of the service.</param>
/// <param name="key">
/// The name under which the object should be registered. Can be <see langword="null"/> or
/// empty.
/// </param>
/// <param name="createInstance">
/// The factory method responsible for serving the requests from the container.
/// </param>
/// <param name="creationPolicy">
/// The creation policy that specifies when and how a service will be instantiated.
/// </param>
/// <param name="disposalPolicy">
/// The disposal policy that specifies when a service instance will be disposed. (Only
/// relevant if the service instance implements <see cref="IDisposable"/>.)
/// </param>
/// <remarks>
/// If a service with the same type and name is already registered, the existing entry will
/// be replaced.
/// </remarks>
/// <exception cref="ArgumentNullException">
/// <paramref name="serviceType"/> or <paramref name="createInstance"/> is
/// <see langword="null"/>.
/// </exception>
public void Register(Type serviceType, string key, Func<ServiceContainer, object> createInstance, CreationPolicy creationPolicy, DisposalPolicy disposalPolicy)
{
ThrowIfDisposed();
if (serviceType == null)
throw new ArgumentNullException(nameof(serviceType));
if (createInstance == null)
throw new ArgumentNullException(nameof(createInstance));
var registration = new ServiceRegistration(serviceType, key);
var entry = new ServiceEntry(createInstance, creationPolicy, disposalPolicy);
lock (_registry)
{
_registry[registration] = entry;
}
}
