public static void SeekBackward()
{
IPlayerContextManager playerContextManager = ServiceRegistration.Get <IPlayerContextManager>();
playerContextManager.SeekBackward();
}
protected override IDictionary <string, MediaCategory> GetAllAvailableCategories()
{
IMediaAccessor mediaAccessor = ServiceRegistration.Get <IMediaAccessor>();
return(mediaAccessor.MediaCategories);
}
public override void ReImportShare()
{
ILocalSharesManagement sharesManagement = ServiceRegistration.Get <ILocalSharesManagement>();
sharesManagement.ReImportShare(_origShare.ShareId);
}
/// <summary>
/// Updates the GUI data for a media items view screen which reflects the data of the <see cref="CurrentView"/>.
/// </summary>
/// <param name="createNewList">If set to <c>true</c>, this method will re-create the
/// <see cref="AbstractScreenData.Items"/> list, else it will reuse it.</param>
protected void UpdateMediaItems(bool createNewList)
{
View view;
// Control other threads reentering this method
lock (_syncObj)
{
if (_buildingList)
{ // Another thread is already building the items list - mark it as dirty and let the other thread
// rebuild it.
_listDirty = true;
return;
}
// Mark the list as being built
view = _view;
InstallViewChangeNotificator(_view.CreateViewChangeNotificator());
_buildingList = true;
_listDirty = false;
}
try
{
Display_ListBeingBuilt();
ItemsList items;
if (createNewList)
{
items = new ItemsList();
}
else
{
items = _items;
items.Clear();
}
try
{
// TODO: Add the items in a separate job while the UI already shows the new screen
if (view.IsValid)
{
// Add items for sub views
IList <View> subViews = view.SubViews;
IList <MediaItem> mediaItems = view.MediaItems;
lock (_syncObj)
if (_listDirty)
{
goto RebuildView;
}
if (subViews == null || mediaItems == null)
{
Display_ItemsInvalid();
}
else
{
if (subViews.Count + mediaItems.Count > Consts.MAX_NUM_ITEMS_VISIBLE)
{
Display_TooManyItems(subViews.Count + mediaItems.Count);
}
else
{
int totalNumItems = 0;
bool subViewsPreSorted = false;
List <NavigationItem> viewsList = new List <NavigationItem>();
foreach (View sv in subViews)
{
if (sv.Specification.SortedSubViews)
{
subViewsPreSorted = true;
}
ViewItem item = new ViewItem(sv, null, sv.AbsNumItems);
View subView = sv;
item.Command = new MethodDelegateCommand(() => NavigateToView(subView.Specification));
viewsList.Add(item);
if (sv.AbsNumItems.HasValue)
{
totalNumItems += sv.AbsNumItems.Value;
}
}
// Morpheus_xx, 2014-05-03: Only sort the subviews here, if they are not pre-sorted by the ViewSpecification
if (!subViewsPreSorted)
{
viewsList.Sort((v1, v2) => string.Compare(v1.SortString, v2.SortString));
}
CollectionUtils.AddAll(items, viewsList);
lock (_syncObj)
if (_listDirty)
{
goto RebuildView;
}
PlayableItemCreatorDelegate picd = PlayableItemCreator;
List <PlayableMediaItem> itemsList = mediaItems.Select(childItem => picd(childItem)).Where(item => item != null).ToList();
Sorting.Sorting sorting = CurrentSorting;
if (sorting != null)
{
itemsList.Sort((i1, i2) => sorting.Compare(i1.MediaItem, i2.MediaItem));
}
else
{
// Default sorting: Use SortString
itemsList.Sort((i1, i2) => string.Compare(i1.SortString, i2.SortString));
}
CollectionUtils.AddAll(items, itemsList);
_currentTotalNumItems = totalNumItems == 0 ? new int?() : totalNumItems;
Display_Normal(items.Count, _currentTotalNumItems);
}
}
}
else
{
Display_ItemsInvalid();
}
}
catch (Exception e)
{
ServiceRegistration.Get <ILogger>().Warn("AbstractItemsScreenData: Error creating items list", e);
Display_ItemsInvalid();
}
RebuildView:
bool dirty;
lock (_syncObj)
if (_listDirty)
{
dirty = true;
_buildingList = false;
}
else
{
dirty = false;
}
if (dirty)
{
UpdateMediaItems(createNewList);
}
else
{
_items = items;
_items.FireChange();
}
}
finally
{
lock (_syncObj)
_buildingList = false;
}
}
protected override bool ShareNameExists(string shareName)
{
ILocalSharesManagement sharesManagement = ServiceRegistration.Get <ILocalSharesManagement>();
return(sharesManagement.Shares.Values.Any(share => (_origShare == null || share.ShareId != _origShare.ShareId) && share.Name == shareName));
}
public override Task <bool> IsAvailableAsync(MediaItem mediaItem)
{
var result = ServiceRegistration.Get <IWorkflowManager>().MenuStateActions.ContainsKey(ACTION_ID_ADD_ALL_TO_PLAYLIST);
return(Task.FromResult(result));
}
public void Close()
{
IPlayerManager playerManager = ServiceRegistration.Get <IPlayerManager>();
playerManager.CloseSlot(_slotController);
}
// Currently unused, teletext subtitles are not yet (re-)implemented!
public void OnTextSubtitle(ref TextSubtitle sub)
{
ServiceRegistration.Get <ILogger>().Debug("On TextSubtitle called");
try
{
if (sub.Page == _activeSubPage)
{
ServiceRegistration.Get <ILogger>().Debug("Page: " + sub.Page);
ServiceRegistration.Get <ILogger>().Debug("Character table: " + sub.Encoding);
ServiceRegistration.Get <ILogger>().Debug("Timeout: " + sub.TimeOut);
ServiceRegistration.Get <ILogger>().Debug("Timestamp" + sub.TimeStamp);
ServiceRegistration.Get <ILogger>().Debug("Language: " + sub.Language);
String content = sub.Text;
if (content == null)
{
ServiceRegistration.Get <ILogger>().Error("OnTextSubtitle: sub.txt == null!");
return;
}
}
}
catch (Exception e)
{
ServiceRegistration.Get <ILogger>().Error("Problem with TEXT_SUBTITLE");
ServiceRegistration.Get <ILogger>().Error(e);
}
try
{
// if we dont need the subtitle
if (!_renderSubtitles || _useBitmap || (_activeSubPage != sub.Page))
{
ServiceRegistration.Get <ILogger>().Debug("Text subtitle (page {0}) discarded: useBitmap is {1} and activeSubPage is {2}", sub.Page, _useBitmap, _activeSubPage);
return;
}
ServiceRegistration.Get <ILogger>().Debug("Text subtitle (page {0}) ACCEPTED: useBitmap is {1} and activeSubPage is {2}", sub.Page, _useBitmap, _activeSubPage);
Subtitle subtitle = new Subtitle(_device)
{
SubBitmap = RenderText(sub.LineContents),
TimeOut = sub.TimeOut,
PresentTime = sub.TimeStamp / 90000.0f + _startPos,
Height = (uint)SkinContext.SkinResources.SkinHeight,
Width = (uint)SkinContext.SkinResources.SkinWidth,
FirstScanLine = 0
};
lock (_subtitles)
{
while (_subtitles.Count >= MAX_SUBTITLES_IN_QUEUE)
{
ServiceRegistration.Get <ILogger>().Debug("SubtitleRenderer: Subtitle queue too big, discarding first element");
_subtitles.RemoveFirst();
}
_subtitles.AddLast(subtitle);
ServiceRegistration.Get <ILogger>().Debug("SubtitleRenderer: Text subtitle added, now have {0} subtitles in cache {1} pos on last render was {2}", _subtitles.Count, subtitle, _currentTime);
}
}
catch (Exception e)
{
ServiceRegistration.Get <ILogger>().Error("Problem processing text subtitle");
ServiceRegistration.Get <ILogger>().Error(e);
}
}
public void DrawOverlay(Texture targetTexture)
{
Subtitle currentSubtitle;
lock (_syncObj)
{
currentSubtitle = _subtitles.ToList().FirstOrDefault(s => s.ShouldDraw);
if (currentSubtitle == null)
{
return;
}
if (targetTexture == null || targetTexture.IsDisposed || currentSubtitle.SubTexture == null || currentSubtitle.SubTexture.IsDisposed)
{
if (_drawCount > 0)
{
ServiceRegistration.Get <ILogger>().Debug("Draw count for last sub: {0}", _drawCount);
}
_drawCount = 0;
return;
}
_drawCount++;
}
try
{
// TemporaryRenderTarget changes RenderTarget to texture and restores settings when done (Dispose)
using (new TemporaryRenderTarget(targetTexture))
using (TemporaryRenderState temporaryRenderState = new TemporaryRenderState())
using (Sprite sprite = new Sprite(_device))
{
sprite.Begin(SpriteFlags.AlphaBlend);
// No alpha test here, allow all values
temporaryRenderState.SetTemporaryRenderState(RenderState.AlphaTestEnable, 0);
// Use the SourceAlpha channel and InverseSourceAlpha for destination
temporaryRenderState.SetTemporaryRenderState(RenderState.BlendOperation, (int)BlendOperation.Add);
temporaryRenderState.SetTemporaryRenderState(RenderState.SourceBlend, (int)Blend.SourceAlpha);
temporaryRenderState.SetTemporaryRenderState(RenderState.DestinationBlend, (int)Blend.InverseSourceAlpha);
// Check the target texture dimensions and adjust scaling and translation
SurfaceDescription desc = targetTexture.GetLevelDescription(0);
Matrix transform = Matrix.Identity;
// Position subtitle and scale it to match video frame size, if required
transform *= Matrix.Translation(currentSubtitle.HorizontalPosition, currentSubtitle.FirstScanLine, 0);
if (currentSubtitle.ScreenWidth != desc.Width || currentSubtitle.ScreenHeight != desc.Height)
{
var factorW = (float)desc.Width / currentSubtitle.ScreenWidth;
var factorH = (float)desc.Height / currentSubtitle.ScreenHeight;
transform *= Matrix.Scaling(factorW, factorH, 1);
}
sprite.Transform = transform;
sprite.Draw(currentSubtitle.SubTexture, SharpDX.Color.White);
sprite.End();
}
if (_onTextureInvalidated != null)
{
_onTextureInvalidated();
}
}
catch (Exception ex)
{
ServiceRegistration.Get <ILogger>().Debug("Error in DrawOverlay", ex);
}
}
public static void ToggleCurrentPlayer()
{
IPlayerContextManager playerContextManager = ServiceRegistration.Get <IPlayerContextManager>();
playerContextManager.ToggleCurrentPlayer();
}
public static void SwitchPipPlayers()
{
IPlayerContextManager playerContextManager = ServiceRegistration.Get <IPlayerContextManager>();
playerContextManager.SwitchPipPlayers();
}
public static void ToggleMute()
{
IPlayerManager playerManager = ServiceRegistration.Get <IPlayerManager>();
playerManager.Muted ^= true;
}
public static void Next()
{
IPlayerContextManager playerContextManager = ServiceRegistration.Get <IPlayerContextManager>();
playerContextManager.NextItem();
}
public static void Previous()
{
IPlayerContextManager playerContextManager = ServiceRegistration.Get <IPlayerContextManager>();
playerContextManager.PreviousItem();
}
private bool CreateOrUpdateRow(bool updateOnly, ref int channelIndex, int rowIndex)
{
if (channelIndex >= ChannelsPrograms.Count)
{
return(false);
}
ChannelProgramListItem channel = ChannelsPrograms[channelIndex] as ChannelProgramListItem;
if (channel == null)
{
return(false);
}
// Default: take viewport from model
var model = SlimTvMultiChannelGuideModel;
if (model == null)
{
return(false);
}
DateTime viewportStart = model.GuideStartTime;
DateTime viewportEnd = model.GuideEndTime;
int colIndex = GroupButtonEnabled ? 1 : 0;
if (!updateOnly)
{
Control btnHeader = CreateControl(channel);
SetGrid(btnHeader, colIndex, rowIndex, 1);
// Deep copy the styles to each program button.
btnHeader.Template = MpfCopyManager.DeepCopyCutLVPs(HeaderTemplate);
Children.Add(btnHeader);
}
int colSpan = 0;
DateTime?lastStartTime = null;
DateTime?lastEndTime = viewportStart;
#if DEBUG_LAYOUT
// Debug layouting:
if (rowIndex == 0)
{
ServiceRegistration.Get <ILogger>().Debug("EPG: Viewport: {0}-{1} PerCell: {2} min", viewportStart.ToShortTimeString(), viewportEnd.ToShortTimeString(), _perCellTime);
}
#endif
if (updateOnly)
{
// Remove all programs outside of viewport.
DateTime start = viewportStart;
DateTime end = viewportEnd;
var removeList = GetRowItems(rowIndex).Where(el =>
{
ProgramListItem p = (ProgramListItem)el.Context;
return(p.Program.EndTime <= start || p.Program.StartTime >= end || channel.Channel.ChannelId != ((IProgram)p.AdditionalProperties["PROGRAM"]).ChannelId ||
p is PlaceholderListItem);
}).ToList();
removeList.ForEach(Children.Remove);
}
colIndex++; // After header (and optional GroupButton)
int programIndex = 0;
while (programIndex < channel.Programs.Count && colIndex <= _numberOfColumns)
{
ProgramListItem program = channel.Programs[programIndex] as ProgramListItem;
if (program == null || program.Program.StartTime > viewportEnd)
{
break;
}
// Ignore programs outside viewport and programs that start at same time (duplicates)
if (program.Program.EndTime <= viewportStart || (lastStartTime.HasValue && lastStartTime.Value == program.Program.StartTime))
{
programIndex++;
continue;
}
lastStartTime = program.Program.StartTime;
CalculateProgamPosition(program, viewportStart, viewportEnd, ref colIndex, ref colSpan, ref lastEndTime);
Control btnEpg = GetOrCreateControl(program, rowIndex);
SetGrid(btnEpg, colIndex, rowIndex, colSpan);
if (ChannelContext.IsSameChannel(channel.Channel, ChannelContext.Instance.Channels.Current) && program.IsRunning && !updateOnly)
{
btnEpg.SetFocusPrio = SetFocusPriority.Highest;
}
programIndex++;
colIndex += colSpan; // Skip spanned columns.
}
channelIndex++;
return(true);
}
/// <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.Album && mediaType != FanArtMediaTypes.Audio)
{
return(false);
}
if (!Guid.TryParse(name, out mediaItemId))
{
return(false);
}
IMediaLibrary mediaLibrary = ServiceRegistration.Get <IMediaLibrary>(false);
if (mediaLibrary == null)
{
return(false);
}
IFilter filter = null;
IList <MediaItem> items = null;
List <Guid> necessaryMias = new List <Guid>(NECESSARY_MIAS);
if (mediaType == FanArtMediaTypes.Album)
{
filter = new RelationshipFilter(AudioAspect.ROLE_TRACK, AudioAlbumAspect.ROLE_ALBUM, mediaItemId);
}
else if (mediaType == FanArtMediaTypes.Audio)
{
//Might be a request for track cover which doesn't exist. Album cover is used instead.
filter = new MediaItemIdFilter(mediaItemId);
}
else
{
return(false);
}
MediaItemQuery mediaQuery = new MediaItemQuery(necessaryMias, filter);
mediaQuery.Limit = 1;
items = mediaLibrary.Search(mediaQuery, 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, "../");
string album = null;
if (MediaItemAspect.TryGetAttribute(mediaItem.Aspects, AudioAspect.ATTR_ALBUM, out album) && LocalFanartHelper.IsDiscFolder(album, mediaItemDirectoryPath.FileName))
{
//Probably a CD folder so try next parent
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.Undefined || fanArtType == FanArtTypes.Poster || fanArtType == FanArtTypes.Cover || fanArtType == FanArtTypes.Thumbnail)
{
fanArtPaths.AddRange(LocalFanartHelper.FilterPotentialFanArtFilesByName(potentialFanArtFiles, LocalFanartHelper.POSTER_FILENAMES));
fanArtPaths.AddRange(LocalFanartHelper.FilterPotentialFanArtFilesByName(potentialFanArtFiles, LocalFanartHelper.THUMB_FILENAMES));
}
if (fanArtType == FanArtTypes.DiscArt)
{
fanArtPaths.AddRange(LocalFanartHelper.FilterPotentialFanArtFilesByName(potentialFanArtFiles, LocalFanartHelper.DISCART_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("LocalAlbumFanArtProvider: Error while searching fanart of type '{0}' for '{1}'", ex, fanArtType, mediaIteamLocator);
#endif
}
result = files;
return(files.Count > 0);
}
protected void GetNowAndNextProgramsList_Async()
{
IThreadPool threadPool = ServiceRegistration.Get <IThreadPool>();
threadPool.Add(GetNowAndNextProgramsList);
}
public static string Translate(string maybeLocalizationResource, params object[] parameters)
{
ILocalization localization = ServiceRegistration.Get <ILocalization>();
return(localization.ToString(maybeLocalizationResource, parameters));
}
public static void ShowPlaylistsOverview()
{
IWorkflowManager workflowManager = ServiceRegistration.Get <IWorkflowManager>();
workflowManager.NavigatePush(Consts.WF_STATE_ID_PLAYLISTS_OVERVIEW);
}
protected override void InitGenreMap()
{
if (_tvGenresInited)
{
return;
}
_tvGenresInited = true;
string genre;
bool enabled;
IGenreConverter converter = ServiceRegistration.Get <IGenreConverter>();
if (converter == null)
{
return;
}
// Get the id of the mp genre identified as the movie genre.
int genreMapMovieGenreId;
if (!int.TryParse(_tvBusiness.GetSetting("genreMapMovieGenreId").Value, out genreMapMovieGenreId))
{
genreMapMovieGenreId = -1;
}
// Each genre map value is a '{' delimited list of "program" genre names (those that may be compared with the genre from the program listings).
// It is an error if a single "program" genre is mapped to more than one guide genre; behavior is undefined for this condition.
int genreIndex = 0;
while (true)
{
// The genremap key is an integer value that is added to a base value in order to locate the correct localized genre name string.
genre = _tvBusiness.GetSetting("genreMapName" + genreIndex).Value;
if (string.IsNullOrEmpty(genre))
{
break;
}
// Get the status of the mp genre.
if (!bool.TryParse(_tvBusiness.GetSetting("genreMapNameEnabled" + genreIndex).Value, out enabled))
{
enabled = true;
}
EpgGenre?epgGenre = null;
if (enabled && genreIndex == genreMapMovieGenreId)
{
epgGenre = EpgGenre.Movie;
}
else if (enabled && !string.IsNullOrEmpty(genre))
{
if (converter.GetGenreId(genre, GenreCategory.Epg, null, out int genreId))
{
epgGenre = (EpgGenre)genreId;
}
}
if (epgGenre.HasValue)
{
string genreMapEntry = _tvBusiness.GetSetting("genreMapEntry" + genreIndex).Value;
if (!string.IsNullOrEmpty(genreMapEntry))
{
_tvGenres.TryAdd(epgGenre.Value, genreMapEntry.Split(new char[] { '{' }, StringSplitOptions.RemoveEmptyEntries));
}
}
genreIndex++;
}
}
protected void ShowProgramActions(IProgram program)
{
if (program == null)
{
return;
}
ILocalization loc = ServiceRegistration.Get <ILocalization>();
_programActions = new ItemsList();
// if program is over already, there is nothing to do.
if (program.EndTime < DateTime.Now)
{
_programActions.Add(new ListItem(Consts.KEY_NAME, loc.ToString("[SlimTvClient.ProgramOver]")));
}
else
{
// Check if program is currently running.
bool isRunning = DateTime.Now >= program.StartTime && DateTime.Now <= program.EndTime;
if (isRunning)
{
_programActions.Add(new ListItem(Consts.KEY_NAME, loc.ToString("[SlimTvClient.WatchNow]"))
{
Command = new MethodDelegateCommand(() =>
{
IChannel channel;
if (_tvHandler.ProgramInfo.GetChannel(program, out channel))
{
IWorkflowManager workflowManager = ServiceRegistration.Get <IWorkflowManager>();
SlimTvClientModel model = workflowManager.GetModel(SlimTvClientModel.MODEL_ID) as SlimTvClientModel;
if (model != null)
{
model.Tune(channel);
}
}
})
});
}
if (_tvHandler.ScheduleControl != null)
{
RecordingStatus recordingStatus;
if (_tvHandler.ScheduleControl.GetRecordingStatus(program, out recordingStatus) && recordingStatus != RecordingStatus.None)
{
if (isRunning)
{
_programActions.Add(
new ListItem(Consts.KEY_NAME, loc.ToString("[SlimTvClient.WatchFromBeginning]"))
{
Command = new MethodDelegateCommand(() => _tvHandler.WatchRecordingFromBeginning(program))
});
}
_programActions.Add(
new ListItem(Consts.KEY_NAME, loc.ToString("[SlimTvClient.DeleteSchedule]"))
{
Command = new MethodDelegateCommand(() =>
{
if (_tvHandler.ScheduleControl.RemoveScheduleForProgram(program, ScheduleRecordingType.Once))
{
UpdateRecordingStatus(program, RecordingStatus.None);
}
}
)
});
}
else
{
_programActions.Add(
new ListItem(Consts.KEY_NAME, loc.ToString(isRunning ? "[SlimTvClient.RecordNow]" : "[SlimTvClient.CreateSchedule]"))
{
Command = new MethodDelegateCommand(() =>
{
ISchedule schedule;
if (_tvHandler.ScheduleControl.CreateSchedule(program, ScheduleRecordingType.Once, out schedule))
{
UpdateRecordingStatus(program, RecordingStatus.Scheduled);
}
}
)
});
}
}
}
// Add list entries for extensions
foreach (KeyValuePair <Guid, TvExtension> programExtension in _programExtensions)
{
TvExtension extension = programExtension.Value;
// First check if this extension applies for the selected program
if (!extension.Extension.IsAvailable(program))
{
continue;
}
_programActions.Add(
new ListItem(Consts.KEY_NAME, loc.ToString(extension.Caption))
{
Command = new MethodDelegateCommand(() => extension.Extension.ProgramAction(program))
});
}
IScreenManager screenManager = ServiceRegistration.Get <IScreenManager>();
screenManager.ShowDialog(_programActionsDialogName);
}
internal static void SendMessageReloadScreens()
{
SystemMessage msg = new SystemMessage(MessageType.ReloadScreens);
ServiceRegistration.Get <IMessageBroker>().Send(CHANNEL, msg);
}
protected override IEnumerable <ResourceProviderMetadata> GetAvailableBaseResourceProviders()
{
IMediaAccessor mediaAccessor = ServiceRegistration.Get <IMediaAccessor>();
return(mediaAccessor.LocalBaseResourceProviders.Select(resourceProvider => resourceProvider.Metadata));
}
public static bool LoadLayoutSettings(string nextScreen, out ScreenConfig screenConfig)
{
ViewSettings viewSettings = ServiceRegistration.Get <ISettingsManager>().Load <ViewSettings>();
return(viewSettings.ScreenConfigs.TryGetValue(nextScreen, out screenConfig));
}
protected override bool SharePathExists(ResourcePath sharePath)
{
ILocalSharesManagement sharesManagement = ServiceRegistration.Get <ILocalSharesManagement>();
return(sharesManagement.Shares.Values.Any(share => (_origShare == null || share.ShareId != _origShare.ShareId) && share.BaseResourcePath == sharePath));
}
public static bool LoadScreenHierarchy(string currentScreen, out string nextScreen)
{
ViewSettings viewSettings = ServiceRegistration.Get <ISettingsManager>().Load <ViewSettings>();
return(viewSettings.ScreenHierarchy.TryGetValue(currentScreen, out nextScreen));
}
public override void UpdateShare(RelocationMode relocationMode)
{
ILocalSharesManagement sharesManagement = ServiceRegistration.Get <ILocalSharesManagement>();
sharesManagement.UpdateShare(_origShare.ShareId, ChoosenResourcePath, ShareName, GetMediaCategoriesCleanedUp(), relocationMode);
}
protected void SwitchToCurrentScreen()
{
ServiceRegistration.Get <IScreenManager>().ShowScreen(_currentScreenData.Screen);
}
public static IEnumerable <Share> GetShares()
{
ILocalSharesManagement sharesManagement = ServiceRegistration.Get <ILocalSharesManagement>();
return(sharesManagement.Shares.Values);
}
public static void Stop()
{
IPlayerContextManager playerContextManager = ServiceRegistration.Get <IPlayerContextManager>();
playerContextManager.Stop();
}