void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (message.ChannelName == ServerConnectionMessaging.CHANNEL)
{
ServerConnectionMessaging.MessageType messageType =
(ServerConnectionMessaging.MessageType)message.MessageType;
switch (messageType)
{
case ServerConnectionMessaging.MessageType.HomeServerAttached:
case ServerConnectionMessaging.MessageType.HomeServerDetached:
case ServerConnectionMessaging.MessageType.HomeServerConnected:
case ServerConnectionMessaging.MessageType.HomeServerDisconnected:
_ = UpdateUserLists_NoLock(false);
break;
}
}
}
private void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (message.ChannelName == ServerConnectionMessaging.CHANNEL)
{
ServerConnectionMessaging.MessageType type = (ServerConnectionMessaging.MessageType)message.MessageType;
switch (type)
{
case ServerConnectionMessaging.MessageType.HomeServerAttached:
_proxyRegistration.RegisterService();
break;
case ServerConnectionMessaging.MessageType.HomeServerDetached:
_proxyRegistration.UnregisterService();
break;
}
}
}
void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (message.ChannelName == WorkflowManagerMessaging.CHANNEL)
{
if ((WorkflowManagerMessaging.MessageType)message.MessageType == WorkflowManagerMessaging.MessageType.StatePushed)
{
var workflowManager = ServiceRegistration.Get <IWorkflowManager>();
var isHomeScreen = workflowManager.CurrentNavigationContext.WorkflowState.StateId.ToString().Equals("7F702D9C-F2DD-42da-9ED8-0BA92F07787F", StringComparison.OrdinalIgnoreCase);
if (isHomeScreen)
{
// Show Dialog
IScreenManager screenManager = ServiceRegistration.Get <IScreenManager>();
screenManager.ShowDialog("whats-new");
}
}
}
}
private void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (message.ChannelName == ServerConnectionMessaging.CHANNEL)
{
ServerConnectionMessaging.MessageType messageType =
(ServerConnectionMessaging.MessageType)message.MessageType;
switch (messageType)
{
case ServerConnectionMessaging.MessageType.HomeServerAttached:
case ServerConnectionMessaging.MessageType.HomeServerDetached:
case ServerConnectionMessaging.MessageType.HomeServerConnected:
case ServerConnectionMessaging.MessageType.HomeServerDisconnected:
SynchronizeHomeServer();
break;
}
}
}
private void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (message.ChannelName == SystemMessaging.CHANNEL)
{
SystemMessaging.MessageType messageType = (SystemMessaging.MessageType)message.MessageType;
switch (messageType)
{
case SystemMessaging.MessageType.SystemStateChanged:
SystemState newState = (SystemState)message.MessageData[SystemMessaging.NEW_STATE];
if (newState == SystemState.Running)
{
StartTimer();
if (UserSettingStorage.AutoLoginUser == Guid.Empty && UserSettingStorage.UserLoginScreenEnabled && UserSettingStorage.UserLoginEnabled)
{
ShowLoginScreen();
}
}
else if (newState == SystemState.Suspending || newState == SystemState.Hibernating)
{
if ((UserSettingStorage.AutoLoginUser == Guid.Empty || UserSettingStorage.AutoLoginUser != CurrentUser?.ProfileId) && UserSettingStorage.UserLoginEnabled)
{
LogoutUser();
}
}
else if (newState == SystemState.ShuttingDown)
{
StopTimer();
}
break;
}
}
else if (message.ChannelName == ServerConnectionMessaging.CHANNEL)
{
ServerConnectionMessaging.MessageType messageType = (ServerConnectionMessaging.MessageType)message.MessageType;
switch (messageType)
{
case ServerConnectionMessaging.MessageType.HomeServerConnected:
if (_firstLogin)
{
_ = SetCurrentUser(); //Auto login user on first connect
}
_ = RefreshUserList();
break;
}
}
}
void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (message.ChannelName == ServerStateMessaging.CHANNEL)
{
if (((ServerStateMessaging.MessageType)message.MessageType) == ServerStateMessaging.MessageType.StatesChanged)
{
var updatedStates = (IDictionary <Guid, object>)message.MessageData[ServerStateMessaging.STATES];
bool fire;
lock (_syncObj)
fire = UpdateStates(updatedStates);
if (fire)
{
FireChange();
}
}
}
}
void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (message.ChannelName == SystemMessaging.CHANNEL)
{
SystemMessaging.MessageType messageType = (SystemMessaging.MessageType)message.MessageType;
if (messageType == SystemMessaging.MessageType.SystemStateChanged)
{
SystemState newState = (SystemState)message.MessageData[SystemMessaging.NEW_STATE];
if (newState == SystemState.Running)
{
_reloadSkinActions.RegisterKeyActions();
_loadSkinThemeActions.RegisterKeyActions();
DropMessageQueue();
}
}
}
}
void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (message.ChannelName == SystemMessaging.CHANNEL)
{
SystemMessaging.MessageType messageType = (SystemMessaging.MessageType)message.MessageType;
if (messageType == SystemMessaging.MessageType.SystemStateChanged)
{
SystemState state = (SystemState)message.MessageData[SystemMessaging.NEW_STATE];
switch (state)
{
case SystemState.ShuttingDown:
UnregisterService();
break;
}
}
}
}
public void Activated(PluginRuntime pluginRuntime)
{
var settingsManager = ServiceRegistration.Get <ISettingsManager>();
var settings = settingsManager.Load <WhatsNewSettings>();
if (settings.NewsConfirmed)
{
return;
}
_messageQueue = new AsynchronousMessageQueue(this.GetType(), new string[]
{
WorkflowManagerMessaging.CHANNEL
});
_messageQueue.MessageReceived += OnMessageReceived;
_messageQueue.Start();
}
private void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (message.ChannelName == SystemMessaging.CHANNEL)
{
SystemMessaging.MessageType messageType = (SystemMessaging.MessageType)message.MessageType;
switch (messageType)
{
case SystemMessaging.MessageType.SystemStateChanged:
SystemState newState = (SystemState)message.MessageData[SystemMessaging.NEW_STATE];
if (newState == SystemState.Resuming)
{
// Signal the event, callback is executed after timeout, see OnResume
_resumeEvent.EnqueueEvent(this, EventArgs.Empty);
}
if (newState == SystemState.Suspending)
{
ServiceRegistration.Get <ILogger>().Info("SlimTvClientModel: System suspending, stopping all SlimTV players");
IPlayerContextManager playerContextManager = ServiceRegistration.Get <IPlayerContextManager>();
for (int index = 0; index < playerContextManager.NumActivePlayerContexts; index++)
{
IPlayerContext playerContext = playerContextManager.GetPlayerContext(index);
if (playerContext != null && playerContext.CurrentMediaItem is LiveTvMediaItem)
{
playerContext.Stop();
_tvWasActive = true;
}
}
}
break;
}
}
else if (message.ChannelName == ServerStateMessaging.CHANNEL)
{
//Check if Tv Server state has changed and update if necessary
ServerStateMessaging.MessageType messageType = (ServerStateMessaging.MessageType)message.MessageType;
if (messageType == ServerStateMessaging.MessageType.StatesChanged)
{
var states = message.MessageData[ServerStateMessaging.STATES] as IDictionary <Guid, object>;
if (states != null && states.ContainsKey(TvServerState.STATE_ID))
{
ServerState = states[TvServerState.STATE_ID] as TvServerState;
}
}
}
}
void SubscribeToMessages()
{
if (_messageQueue != null)
{
return;
}
_messageQueue = new AsynchronousMessageQueue(this, new string[]
{
PlayerManagerMessaging.CHANNEL,
SystemMessaging.CHANNEL
});
_messageQueue.MessageReceived += OnMessageReceived;
_messageQueue.Start();
_timer = new Timer(DEFAULT_CHECK_INTERVAL);
_timer.Elapsed += CheckVideoResolution;
_timer.Start();
}
private void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (message.ChannelName == SystemMessaging.CHANNEL)
{
SystemMessaging.MessageType messageType =
(SystemMessaging.MessageType)message.MessageType;
switch (messageType)
{
case SystemMessaging.MessageType.SystemStateChanged:
SystemState newState = (SystemState)message.MessageData[SystemMessaging.NEW_STATE];
if (newState == SystemState.ShuttingDown)
{
IsSuspended = true;
}
break;
}
}
}
public void Activated(PluginRuntime pluginRuntime)
{
ISystemStateService sss = ServiceRegistration.Get <ISystemStateService>();
if (sss.CurrentState == SystemState.Running)
{
RegisterKeyBindings();
}
else
{
_messageQueue = new AsynchronousMessageQueue(typeof(StatisticsRenderer), new string[]
{
SystemMessaging.CHANNEL
});
_messageQueue.MessageReceived += OnMessageReceived;
_messageQueue.Start();
}
}
private void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (message.ChannelName == ClientManagerMessaging.CHANNEL)
{
ClientManagerMessaging.MessageType messageType =
(ClientManagerMessaging.MessageType)message.MessageType;
switch (messageType)
{
case ClientManagerMessaging.MessageType.ClientAttached:
case ClientManagerMessaging.MessageType.ClientDetached:
case ClientManagerMessaging.MessageType.ClientOnline:
case ClientManagerMessaging.MessageType.ClientOffline:
ParameterlessMethod d = UpdateClientsList;
Invoke(d);
break;
}
}
}
public ServerConnectionManager()
{
_messageQueue = new AsynchronousMessageQueue(this, new string[]
{
SharesMessaging.CHANNEL,
ImporterWorkerMessaging.CHANNEL,
ServerStateMessaging.CHANNEL
});
_messageQueue.MessageReceived += OnMessageReceived;
_messageQueue.Start();
string homeServerSystemId = HomeServerSystemId;
if (string.IsNullOrEmpty(homeServerSystemId))
// Watch for all MP2 media servers, if we don't have a homeserver yet
_serverWatcher = BuildServerWatcher();
else
// If we have a homeserver set, we'll try to connect to it
_controlPoint = BuildClientControlPoint(homeServerSystemId);
}
private void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (message.ChannelName == ContentDirectoryMessaging.CHANNEL)
{
ContentDirectoryMessaging.MessageType messageType = (ContentDirectoryMessaging.MessageType)message.MessageType;
switch (messageType)
{
case ContentDirectoryMessaging.MessageType.MediaItemChanged:
MediaItem mediaItem = (MediaItem)message.MessageData[ContentDirectoryMessaging.MEDIA_ITEM];
ContentDirectoryMessaging.MediaItemChangeType changeType = (ContentDirectoryMessaging.MediaItemChangeType)message.MessageData[ContentDirectoryMessaging.MEDIA_ITEM_CHANGE_TYPE];
if (changeType == ContentDirectoryMessaging.MediaItemChangeType.Updated)
{
MediaItemChanged?.Invoke(mediaItem);
}
break;
}
}
}
void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (message.ChannelName == WindowsMessaging.CHANNEL)
{
WindowsMessaging.MessageType messageType = (WindowsMessaging.MessageType)message.MessageType;
switch (messageType)
{
case WindowsMessaging.MessageType.WindowsBroadcast:
Message msg = (Message)message.MessageData[WindowsMessaging.MESSAGE];
Handler handler = _handler;
if (handler != null)
{
handler.ProcessInput(ref msg);
}
break;
}
}
}
private void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (!IsSystemActive())
{
return;
}
InitMenu();
if (message.ChannelName == MenuModelMessaging.CHANNEL)
{
if ((MenuModelMessaging.MessageType)message.MessageType == MenuModelMessaging.MessageType.UpdateMenu)
{
UpdateShortcuts();
}
}
if (message.ChannelName == WorkflowManagerMessaging.CHANNEL)
{
IsHomeScreen = ServiceRegistration.Get <IWorkflowManager>().CurrentNavigationContext.WorkflowState.StateId.ToString().Equals("7F702D9C-F2DD-42da-9ED8-0BA92F07787F", StringComparison.OrdinalIgnoreCase);
if ((WorkflowManagerMessaging.MessageType)message.MessageType == WorkflowManagerMessaging.MessageType.StatePushed)
{
if (!string.Equals(_menuSettings.Settings.DefaultMenuGroupId, MenuSettings.MENU_ID_PLAYING, StringComparison.OrdinalIgnoreCase))
{
_lastActiveGroup = _menuSettings.Settings.DefaultMenuGroupId;
}
UpdateSelectedGroup();
}
if ((WorkflowManagerMessaging.MessageType)message.MessageType == WorkflowManagerMessaging.MessageType.StatesPopped)
{
UpdateSelectedGroup();
// MP2-665: Make sure to recreate the main tiles when navigating back into Home screen
if (IsHomeScreen)
{
CreatePositionedItems();
}
}
if ((WorkflowManagerMessaging.MessageType)message.MessageType == WorkflowManagerMessaging.MessageType.NavigationComplete)
{
CheckShortCutsWorkflows();
SetWorkflowName();
_navigated = true;
}
}
}
private void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (message.ChannelName == PlaylistMessaging.CHANNEL)
{
PlaylistMessaging.MessageType messageType = (PlaylistMessaging.MessageType)message.MessageType;
switch (messageType)
{
case PlaylistMessaging.MessageType.PlaylistUpdate:
UpdatePlaylist();
break;
case PlaylistMessaging.MessageType.PropertiesChange:
UpdateProperties();
break;
}
}
else if (message.ChannelName == PlayerManagerMessaging.CHANNEL)
{
PlayerManagerMessaging.MessageType messageType = (PlayerManagerMessaging.MessageType)message.MessageType;
switch (messageType)
{
case PlayerManagerMessaging.MessageType.PlayerSlotClosed:
IPlayerContextManager playerContextManager = ServiceRegistration.Get <IPlayerContextManager>();
ISystemStateService sss = ServiceRegistration.Get <ISystemStateService>();
IPlayerContext pc = playerContextManager.GetPlayerContext(PlayerChoice.CurrentPlayer);
if (pc == null && sss.CurrentState == SystemState.Running)
{
IWorkflowManager workflowManager = ServiceRegistration.Get <IWorkflowManager>();
workflowManager.NavigatePopToState(Consts.WF_STATE_ID_EDIT_PLAYLIST, true);
}
break;
}
}
else if (message.ChannelName == PlayerContextManagerMessaging.CHANNEL)
{
PlayerContextManagerMessaging.MessageType messageType = (PlayerContextManagerMessaging.MessageType)message.MessageType;
switch (messageType)
{
case PlayerContextManagerMessaging.MessageType.CurrentPlayerChanged:
UpdatePlaylist();
break;
}
}
}
protected void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
// Do not handle messages if control is not running. This is a workaround to avoid updating controls that are not used on screen.
// The EpgGrid is instantiated twice: via ScreenManager.LoadScreen and Control.OnTemplateChanged as copy!?
if (ElementState != ElementState.Running)
{
return;
}
if (message.ChannelName == SlimTvClientMessaging.CHANNEL)
{
SlimTvClientMessaging.MessageType messageType = (SlimTvClientMessaging.MessageType)message.MessageType;
switch (messageType)
{
case SlimTvClientMessaging.MessageType.GroupChanged:
OnGroupChanged();
break;
case SlimTvClientMessaging.MessageType.ProgramsChanged:
if (message.MessageData.TryGetValue("MoveCursor", out object difference) && difference is TimeSpan)
{
SaveFocusPosition(out _);
if (_focusTime != DateTime.MinValue)
{
SetFocusTime(_focusTime + (TimeSpan)difference);
}
}
OnProgramsChanged();
break;
case SlimTvClientMessaging.MessageType.ProgramStatusChanged:
IProgram program = (IProgram)message.MessageData[SlimTvClientMessaging.KEY_PROGRAM];
UpdateProgramStatus(program);
break;
case SlimTvClientMessaging.MessageType.GoToChannelIndex:
if (message.MessageData.TryGetValue("Channel", out object channel) && channel is int)
{
SkipToChannelIndex((int)channel);
}
break;
}
}
}
public void Activated(PluginRuntime pluginRuntime)
{
ISystemStateService sss = ServiceRegistration.Get <ISystemStateService>();
if (sss.CurrentState == SystemState.Running)
{
_reloadSkinActions.RegisterKeyActions();
_loadSkinThemeActions.RegisterKeyActions();
}
else
{
_messageQueue = new AsynchronousMessageQueue(typeof(ReloadSkinActions), new string[]
{
SystemMessaging.CHANNEL
});
_messageQueue.MessageReceived += OnMessageReceived;
_messageQueue.Start();
}
}
private void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (message.ChannelName == ContentDirectoryMessaging.CHANNEL)
{
ContentDirectoryMessaging.MessageType messageType = (ContentDirectoryMessaging.MessageType)message.MessageType;
switch (messageType)
{
case ContentDirectoryMessaging.MessageType.MediaItemChanged:
MediaItem mediaItem = (MediaItem)message.MessageData[ContentDirectoryMessaging.MEDIA_ITEM];
ContentDirectoryMessaging.MediaItemChangeType changeType = (ContentDirectoryMessaging.MediaItemChangeType)message.MessageData[ContentDirectoryMessaging.MEDIA_ITEM_CHANGE_TYPE];
UpdateLoadedMediaItems(mediaItem, changeType);
break;
case ContentDirectoryMessaging.MessageType.ShareImportCompleted:
Reload();
break;
}
}
}
private void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (message.ChannelName == ClientManagerMessaging.CHANNEL)
{
ClientManagerMessaging.MessageType messageType = (ClientManagerMessaging.MessageType)message.MessageType;
switch (messageType)
{
case ClientManagerMessaging.MessageType.ClientAttached:
case ClientManagerMessaging.MessageType.ClientDetached:
AttachedClientsChangeCounter.Value = ++_attachedClientsChangeCt;
break;
case ClientManagerMessaging.MessageType.ClientOnline:
case ClientManagerMessaging.MessageType.ClientOffline:
ConnectedClientsChangeCounter.Value = ++_connectedClientsChangeCt;
break;
}
}
}
protected virtual void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (message.ChannelName == WindowsMessaging.CHANNEL)
{
Message m = (Message)message.MessageData[WindowsMessaging.MESSAGE];
if (m.LParam.Equals(_instancePtr))
{
if (m.Msg == WM_GRAPHNOTIFY)
{
IMediaEventEx eventEx = (IMediaEventEx)_graphBuilder;
EventCode evCode;
int param1, param2;
while (eventEx.GetEvent(out evCode, out param1, out param2, 0) == 0)
{
eventEx.FreeEventParams(evCode, param1, param2);
if (evCode == EventCode.Complete)
{
bool hasNextPart = _mediaItem != null && _mediaItem.ActiveResourceLocatorIndex < _mediaItem.MaximumResourceLocatorIndex;
if (hasNextPart)
{
// Request next item
FireNextItemRequest();
}
else if (_autoRepeat)
{
CurrentTime = TimeSpan.Zero;
}
else
{
_state = PlayerState.Ended;
ServiceRegistration.Get <ILogger>().Debug("{0}: Playback ended", PlayerTitle);
// TODO: RemoveResumeData();
FireEnded();
}
return;
}
}
}
}
}
}
void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (message.ChannelName == ServerConnectionMessaging.CHANNEL)
{
ServerConnectionMessaging.MessageType messageType =
(ServerConnectionMessaging.MessageType)message.MessageType;
switch (messageType)
{
case ServerConnectionMessaging.MessageType.HomeServerAttached:
case ServerConnectionMessaging.MessageType.HomeServerDetached:
case ServerConnectionMessaging.MessageType.HomeServerConnected:
UpdateProperties_NoLock();
UpdateSharesLists_NoLock(false);
break;
case ServerConnectionMessaging.MessageType.HomeServerDisconnected:
if (_shareProxy is ServerShares)
{
// If in edit workflow for a server share, when the server gets disconneted, go back to the shares overview
NavigateBackToOverview();
}
else
{
UpdateProperties_NoLock();
UpdateSharesLists_NoLock(false);
}
break;
}
}
else if (message.ChannelName == SharesMessaging.CHANNEL)
{
SharesMessaging.MessageType messageType =
(SharesMessaging.MessageType)message.MessageType;
switch (messageType)
{
case SharesMessaging.MessageType.ShareAdded:
case SharesMessaging.MessageType.ShareRemoved:
UpdateProperties_NoLock();
UpdateSharesLists_NoLock(false);
break;
}
}
}
public OnlineVideosWorkflowModel()
{
SitesList = new ItemsList();
OnlineVideosAppDomain.UseSeperateDomain = true;
ServiceRegistration.Get <ISettingsManager>().Load <Configuration.Settings>().SetValuesToApi();
string ovConfigPath = ServiceRegistration.Get <IPathManager>().GetPath(string.Format(@"<CONFIG>\{0}\", Environment.UserName));
string ovDataPath = ServiceRegistration.Get <IPathManager>().GetPath(@"<DATA>\OnlineVideos");
OnlineVideoSettings.Instance.Logger = new LogDelegator();
OnlineVideoSettings.Instance.UserStore = new Configuration.UserSiteSettingsStore();
OnlineVideoSettings.Instance.DllsDir = System.IO.Path.Combine(ovDataPath, "SiteUtils");
OnlineVideoSettings.Instance.ThumbsDir = System.IO.Path.Combine(ovDataPath, "Thumbs");
OnlineVideoSettings.Instance.ConfigDir = ovConfigPath;
OnlineVideoSettings.Instance.AddSupportedVideoExtensions(new List <string>()
{
".asf", ".asx", ".flv", ".m4v", ".mov", ".mkv", ".mp4", ".wmv"
});
// clear cache files that might be left over from an application crash
MPUrlSourceFilter.Downloader.ClearDownloadCache();
// load translation strings in other AppDomain, so SiteUtils can use localized language strings
TranslationLoader.LoadTranslations(ServiceRegistration.Get <ILocalization>().CurrentCulture.TwoLetterISOLanguageName, System.IO.Path.Combine(System.IO.Path.GetDirectoryName(GetType().Assembly.Location), "Language"), "en", "strings_{0}.xml");
// The default connection limit is 2 in .Net on most platforms! This means downloading two files will block all other WebRequests.
System.Net.ServicePointManager.DefaultConnectionLimit = 100;
// The default .Net implementation for URI parsing removes trailing dots, which is not correct
Helpers.DotNetFrameworkHelper.FixUriTrailingDots();
// load the xml that holds all configured sites
OnlineVideoSettings.Instance.LoadSites();
// create a message queue where we listen to changes to the sites
_messageQueue = new AsynchronousMessageQueue(this, new string[] { OnlineVideosMessaging.CHANNEL });
_messageQueue.MessageReceived += new MessageReceivedHandler(OnlineVideosMessageReceived);
// listen to changes of configuration settings
_settingsWatcher = new SettingsChangeWatcher <Configuration.Settings>();
_settingsWatcher.SettingsChanged += OnlineVideosSettingsChanged;
}
void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (message.ChannelName == ServerConnectionMessaging.CHANNEL)
{
ServerConnectionMessaging.MessageType messageType =
(ServerConnectionMessaging.MessageType)message.MessageType;
switch (messageType)
{
case ServerConnectionMessaging.MessageType.HomeServerAttached:
case ServerConnectionMessaging.MessageType.HomeServerDetached:
case ServerConnectionMessaging.MessageType.HomeServerConnected:
case ServerConnectionMessaging.MessageType.HomeServerDisconnected:
case ServerConnectionMessaging.MessageType.ClientsOnlineStateChanged:
UpdateProperties_NoLock();
UpdateSharesList_NoLock(false);
break;
}
}
else if (message.ChannelName == ContentDirectoryMessaging.CHANNEL)
{
ContentDirectoryMessaging.MessageType messageType =
(ContentDirectoryMessaging.MessageType)message.MessageType;
switch (messageType)
{
case ContentDirectoryMessaging.MessageType.RegisteredSharesChanged:
UpdateSharesList_NoLock(false);
break;
case ContentDirectoryMessaging.MessageType.ShareImportStarted:
case ContentDirectoryMessaging.MessageType.ShareImportCompleted:
Guid shareId = (Guid)message.MessageData[ContentDirectoryMessaging.SHARE_ID];
IServerConnectionManager scm = ServiceRegistration.Get <IServerConnectionManager>();
IContentDirectory cd = scm.ContentDirectory;
if (cd == null)
{
break;
}
UpdateShareImportState_NoLock(shareId, messageType == ContentDirectoryMessaging.MessageType.ShareImportStarted);
break;
}
}
}
void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (message.ChannelName == RemovableMediaMessaging.CHANNEL)
{
RemovableMediaMessaging.MessageType messageType = (RemovableMediaMessaging.MessageType)message.MessageType;
if (messageType == RemovableMediaMessaging.MessageType.MediaInserted)
{
string drive = (string)message.MessageData[RemovableMediaMessaging.DRIVE_LETTER];
RemovableMediaManagerSettings settings = ServiceRegistration.Get <ISettingsManager>().Load <RemovableMediaManagerSettings>();
if (settings.AutoPlay == AutoPlayType.AutoPlay)
{
IPlayerContextManager pcm = ServiceRegistration.Get <IPlayerContextManager>();
if (!pcm.IsFullscreenContentWorkflowStateActive)
{
ExamineVolume(drive);
}
}
}
}
}
private void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (message.ChannelName == SettingsManagerMessaging.CHANNEL)
{
SettingsManagerMessaging.MessageType messageType = (SettingsManagerMessaging.MessageType)message.MessageType;
if (messageType == SettingsManagerMessaging.MessageType.SettingsChanged)
{
Type settingsType = (Type)message.MessageData[SettingsManagerMessaging.SETTINGSTYPE];
Update(settingsType);
}
}
else if (message.ChannelName == PluginManagerMessaging.CHANNEL)
{
PluginManagerMessaging.MessageType messageType = (PluginManagerMessaging.MessageType)message.MessageType;
if (messageType == PluginManagerMessaging.MessageType.PluginsInitialized)
{
InitRegisteredSettings();
}
}
}
private void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (message.ChannelName == ImporterWorkerMessaging.CHANNEL)
{
ImporterWorkerMessaging.MessageType messageType = (ImporterWorkerMessaging.MessageType)message.MessageType;
switch (messageType)
{
case ImporterWorkerMessaging.MessageType.ImportStarted:
if (Interlocked.Increment(ref _importerCount) == 1)
{
IMediaFanArtHandler fanartHandler;
if (ServiceRegistration.Get <IMediaAccessor>().LocalFanArtHandlers.TryGetValue(MovieFanArtHandler.FANARTHANDLER_ID, out fanartHandler))
{
fanartHandler.ClearCache();
}
}
break;
}
}
}
