void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (message.ChannelName == SystemMessaging.CHANNEL)
{
SystemMessaging.MessageType messageType = (SystemMessaging.MessageType)message.MessageType;
if (messageType == SystemMessaging.MessageType.SystemStateChanged)
{
if (!_autoStart)
{
return;
}
SystemState state = (SystemState)message.MessageData[SystemMessaging.NEW_STATE];
switch (state)
{
case SystemState.Running:
StartTimer();
break;
case SystemState.ShuttingDown:
StopTimer();
break;
}
}
}
}
void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (message.ChannelName == ServerConnectionMessaging.CHANNEL)
{
ServerConnectionMessaging.MessageType type = (ServerConnectionMessaging.MessageType)message.MessageType;
switch (type)
{
case ServerConnectionMessaging.MessageType.HomeServerConnected:
case ServerConnectionMessaging.MessageType.HomeServerAttached:
UpdateServerAddress();
break;
}
}
else 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.Suspending)
{
_suspended = true;
}
else if (newState == SystemState.Resuming && _suspended)
{
_suspended = false;
DoWakeServer();
}
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.ShuttingDown)
{
IsSuspended = true;
}
break;
}
}
if (message.ChannelName == TaskSchedulerMessaging.CHANNEL)
{
TaskSchedulerMessaging.MessageType messageType = (TaskSchedulerMessaging.MessageType)message.MessageType;
switch (messageType)
{
case TaskSchedulerMessaging.MessageType.DUE:
Task dueTask = (Task)message.MessageData[TaskSchedulerMessaging.TASK];
if (dueTask.ID == _importerTaskId)
{
// Forward a new message which will be handled by MediaLibrary (it knows the shares and configuration), then it will
// schedule the local shares.
ImporterWorkerMessaging.SendImportMessage(ImporterWorkerMessaging.MessageType.RefreshLocalShares);
}
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.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;
}
}
}
private 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)
{
RestorePendingActions();
}
}
}
else if (message.ChannelName == MediaLibraryMessaging.CHANNEL)
{
MediaLibraryMessaging.MessageType messageType = (MediaLibraryMessaging.MessageType)message.MessageType;
if (messageType == MediaLibraryMessaging.MessageType.MediaItemsAddedOrUpdated)
{
IEnumerable <Guid> ids = message.MessageData[MediaLibraryMessaging.PARAM] as IEnumerable <Guid>;
if (ids != null)
{
foreach (Guid id in ids)
{
ScheduleAnalysis(id);
}
}
}
else if (messageType == MediaLibraryMessaging.MessageType.MediaItemsDeleted)
{
ScheduleAnalysisCleanup();
}
}
}
void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (message.ChannelName == SystemMessaging.CHANNEL)
{
SystemMessaging.MessageType messageType = (SystemMessaging.MessageType)message.MessageType;
ISystemStateService sss = ServiceRegistration.Get <ISystemStateService>();
if (messageType == SystemMessaging.MessageType.SystemStateChanged)
{
if (sss.CurrentState == SystemState.ShuttingDown || sss.CurrentState == SystemState.Ending)
{
UnsubscribeFromMessages();
}
}
}
if (message.ChannelName == PlayerManagerMessaging.CHANNEL)
{
// React to player changes
PlayerManagerMessaging.MessageType messageType = (PlayerManagerMessaging.MessageType)message.MessageType;
switch (messageType)
{
case PlayerManagerMessaging.MessageType.PlayerStarted:
IPlayerSlotController psc = (IPlayerSlotController)message.MessageData[PlayerManagerMessaging.PLAYER_SLOT_CONTROLLER];
HandleVideoEffectSelection(psc);
break;
}
}
}
private 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)
{
RestorePendingActions();
}
}
}
else if (message.ChannelName == MediaLibraryMessaging.CHANNEL)
{
MediaLibraryMessaging.MessageType messageType = (MediaLibraryMessaging.MessageType)message.MessageType;
if (messageType == MediaLibraryMessaging.MessageType.MediaItemsAddedOrUpdated)
{
IEnumerable <MediaItem> items = message.MessageData[MediaLibraryMessaging.PARAM] as IEnumerable <MediaItem>;
if (items != null)
{
foreach (MediaItem item in items)
{
ScheduleFanArtCollection(item.MediaItemId, item.Aspects);
}
}
}
else if (messageType == MediaLibraryMessaging.MessageType.MediaItemsDeleted)
{
ScheduleFanArtCleanup();
}
}
}
//This handler is called synchronously, we complete the blocks in here when the system state changes
//to ShuttingDown to ensure that all pending tasks are completed whilst all services are still available
private void OnPreviewMessage(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.ShuttingDown)
{
CompleteBlocks();
}
}
}
}
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();
}
}
}
}
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 == 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;
}
}
}
}
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;
}
}
}
void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (message.ChannelName == ServerConnectionMessaging.CHANNEL)
{
ServerConnectionMessaging.MessageType type = (ServerConnectionMessaging.MessageType)message.MessageType;
switch (type)
{
case ServerConnectionMessaging.MessageType.HomeServerAttached:
RegisterService();
break;
case ServerConnectionMessaging.MessageType.HomeServerDisconnected:
case ServerConnectionMessaging.MessageType.HomeServerDetached:
UnregisterService();
break;
}
}
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.Suspending:
ITvProvider tvProvider = ServiceRegistration.Get <ITvProvider>(false);
if (tvProvider != null)
{
tvProvider.DeInit();
}
break;
case SystemState.ShuttingDown:
// Called to make sure that timeshifting on server is stopped on shutdown.
UnregisterService();
break;
}
}
}
}
public void Receive(SystemMessage message)
{
if (message.ChannelName == SystemMessaging.CHANNEL)
{
SystemMessaging.MessageType messageType = (SystemMessaging.MessageType)message.MessageType;
ISystemStateService sss = ServiceRegistration.Get <ISystemStateService>();
if (messageType == SystemMessaging.MessageType.SystemStateChanged)
{
if (sss.CurrentState == SystemState.ShuttingDown || sss.CurrentState == SystemState.Ending)
{
// It is necessary to block the main thread until our message delivery thread has delivered all pending
// messages to avoid asynchronous threads during the shutdown phase.
// It's a bit illegal to call the Shutdown() method which acquires a lock in this synchronous message
// handler method. But as we know that the SystemStateChanged message is only called by our application
// main thread which doesn't hold locks, this won't cause deadlocks.
// How ugly, but that's life.
_owner.Shutdown();
}
}
}
}
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)
{
RegisterKeyBindings();
}
if (newState == SystemState.ShuttingDown)
{
DisableStats();
UnregisterKeyBindings();
DropMessageQueue();
}
}
}
}
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)
{
DoResume();
}
if (newState == SystemState.Suspending)
{
DoSuspend();
}
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.Suspending)
{
ServiceRegistration.Get <ILogger>().Info("SlimTVMPExtendedProvider: System suspending, stopping timeshift.");
DeInit();
}
if (newState == SystemState.Resuming)
{
ServiceRegistration.Get <ILogger>().Info("SlimTVMPExtendedProvider: System resuming, init connections.");
Init();
}
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.Suspending)
{
_suspended = true;
}
if (newState == SystemState.Resuming && _suspended)
{
_suspended = false;
ServiceRegistration.Get <ILogger>().Info("UPnPSystemResumeHelper: System resuming, trigger UpdateConfiguration for UPnPServer.");
_upnpServer.UpdateConfiguration();
}
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.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 ltvi)
{
if (ltvi.AdditionalProperties.ContainsKey(LiveTvMediaItem.CHANNEL))
{
_ = UpdateWatchDuration((IChannel)ltvi.AdditionalProperties[LiveTvMediaItem.CHANNEL]);
}
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;
}
}
}
else if (message.ChannelName == PlayerManagerMessaging.CHANNEL)
{
PlayerManagerMessaging.MessageType messageType = (PlayerManagerMessaging.MessageType)message.MessageType;
switch (messageType)
{
case PlayerManagerMessaging.MessageType.PlayerStopped:
case PlayerManagerMessaging.MessageType.PlayerEnded:
if (_lastTunedChannel != null)
{
_ = UpdateWatchDuration(_lastTunedChannel);
}
break;
}
}
}
private 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)
{
Initialise();
}
}
}
else if (message.ChannelName == PlayerManagerMessaging.CHANNEL)
{
PlayerManagerMessaging.MessageType messageType = (PlayerManagerMessaging.MessageType)message.MessageType;
if (messageType == PlayerManagerMessaging.MessageType.PlayerStarted)
{
Log.Info("Playback started.");
ContentEffect effect;
// What kind of playback?
// Video gets highest priority in PiP.
if (ServiceRegistration.Get <IPlayerContextManager>().IsVideoContextActive)
{
effect = settings.VideoEffect;
}
else if (ServiceRegistration.Get <IPlayerContextManager>().IsAudioContextActive)
{
effect = settings.AudioEffect;
}
else
{
return;
}
// Start the right effect.
if (CheckForStartRequirements())
{
coreObject.ChangeEffect(effect);
CalculateDelay();
}
else
{
coreObject.ChangeEffect(ContentEffect.LEDsDisabled);
}
}
else if (messageType == PlayerManagerMessaging.MessageType.PlayerStopped ||
messageType == PlayerManagerMessaging.MessageType.PlayerEnded)
{
Log.Info("Playback stopped.");
ContentEffect effect;
// Is there still something playing? (PiP)
// If yes, what?
if (ServiceRegistration.Get <IPlayerContextManager>().IsVideoContextActive)
{
Log.Info("Another video player is still active (PiP).");
effect = settings.VideoEffect;
}
else if (ServiceRegistration.Get <IPlayerContextManager>().IsAudioContextActive)
{
Log.Info("Another audio player is still active (PiP).");
effect = settings.AudioEffect;
}
else
{
effect = settings.MenuEffect;
}
if (CheckForStartRequirements())
{
coreObject.ChangeEffect(effect);
CalculateDelay();
}
else
{
coreObject.ChangeEffect(ContentEffect.LEDsDisabled);
}
}
}
}
