private void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (message.ChannelName == PlayerManagerMessaging.CHANNEL)
{
PlayerManagerMessaging.MessageType messageType = (PlayerManagerMessaging.MessageType)message.MessageType;
switch (messageType)
{
case PlayerManagerMessaging.MessageType.PlayerStarted:
case PlayerManagerMessaging.MessageType.PlayerStopped:
case PlayerManagerMessaging.MessageType.PlayerEnded:
HandlePlayerChange();
break;
case PlayerManagerMessaging.MessageType.PlaybackStateChanged:
HandlePlaybackStateChanged();
break;
}
}
else if (message.ChannelName == PlayerContextManagerMessaging.CHANNEL)
{
PlayerContextManagerMessaging.MessageType messageType = (PlayerContextManagerMessaging.MessageType)message.MessageType;
switch (messageType)
{
case PlayerContextManagerMessaging.MessageType.PlayerSlotsChanged:
HandlePlayerChange();
break;
}
}
}
void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (message.ChannelName == PlayerManagerMessaging.CHANNEL)
{
// React to player changes
PlayerManagerMessaging.MessageType messageType = (PlayerManagerMessaging.MessageType)message.MessageType;
switch (messageType)
{
case PlayerManagerMessaging.MessageType.PlayerResumeState:
IResumeState resumeState = (IResumeState)message.MessageData[PlayerManagerMessaging.KEY_RESUME_STATE];
PositionResumeState positionResume = resumeState as PositionResumeState;
if (positionResume != null)
{
TimeSpan resumePosition = positionResume.ResumePosition;
_progress = Math.Min((int)(resumePosition.TotalSeconds * 100 / _duration.TotalSeconds), 100);
}
break;
case PlayerManagerMessaging.MessageType.PlayerError:
case PlayerManagerMessaging.MessageType.PlayerEnded:
case PlayerManagerMessaging.MessageType.PlayerStopped:
StopScrobble();
break;
case PlayerManagerMessaging.MessageType.PlayerStarted:
var psc = (IPlayerSlotController)message.MessageData[PlayerManagerMessaging.PLAYER_SLOT_CONTROLLER];
CreateScrobbleData(psc);
StartScrobble();
break;
}
}
}
void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (message.ChannelName == PlayerManagerMessaging.CHANNEL)
{
// React to player changes
PlayerManagerMessaging.MessageType messageType = (PlayerManagerMessaging.MessageType)message.MessageType;
IPlayerSlotController psc;
// ServiceRegistration.Get<ILogger>().Debug("Trakt.tv: PlayerManagerMessage: {0}", message.MessageType);
switch (messageType)
{
case PlayerManagerMessaging.MessageType.PlayerResumeState:
psc = (IPlayerSlotController)message.MessageData[PlayerManagerMessaging.PLAYER_SLOT_CONTROLLER];
IResumeState resumeState = (IResumeState)message.MessageData[PlayerManagerMessaging.KEY_RESUME_STATE];
Guid mediaItemId = (Guid)message.MessageData[PlayerManagerMessaging.KEY_MEDIAITEM_ID];
HandleResumeInfo(psc, mediaItemId, resumeState);
break;
case PlayerManagerMessaging.MessageType.PlayerError:
case PlayerManagerMessaging.MessageType.PlayerEnded:
case PlayerManagerMessaging.MessageType.PlayerStopped:
psc = (IPlayerSlotController)message.MessageData[PlayerManagerMessaging.PLAYER_SLOT_CONTROLLER];
HandleScrobble(psc, false);
break;
case PlayerManagerMessaging.MessageType.PlayerStarted:
psc = (IPlayerSlotController)message.MessageData[PlayerManagerMessaging.PLAYER_SLOT_CONTROLLER];
HandleScrobble(psc, true);
break;
}
}
}
private void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (message.ChannelName == PlayerManagerMessaging.CHANNEL)
{
PlayerManagerMessaging.MessageType messageType = (PlayerManagerMessaging.MessageType)message.MessageType;
switch (messageType)
{
case PlayerManagerMessaging.MessageType.PlayerStarted:
case PlayerManagerMessaging.MessageType.PlayerStopped:
case PlayerManagerMessaging.MessageType.PlayerEnded:
case PlayerManagerMessaging.MessageType.PlayerSlotsChanged:
{
IPlayerManager playerManager = ServiceRegistration.Get <IPlayerManager>();
ISlimDXVideoPlayer player = playerManager[PlayerManagerConsts.PRIMARY_SLOT] as ISlimDXVideoPlayer;
UpdateVideoPlayerState(player);
SynchronizeToVideoPlayerFramerate(player);
break;
}
case PlayerManagerMessaging.MessageType.PlaybackStateChanged:
{
IPlayerManager playerManager = ServiceRegistration.Get <IPlayerManager>();
ISlimDXVideoPlayer player = playerManager[PlayerManagerConsts.PRIMARY_SLOT] as ISlimDXVideoPlayer;
UpdateVideoPlayerState(player);
break;
}
}
}
}
private void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (message.ChannelName == PlayerContextManagerMessaging.CHANNEL)
{
PlayerContextManagerMessaging.MessageType messageType = (PlayerContextManagerMessaging.MessageType)message.MessageType;
switch (messageType)
{
case PlayerContextManagerMessaging.MessageType.CurrentPlayerChanged:
Update();
break;
}
}
else if (message.ChannelName == PlayerManagerMessaging.CHANNEL)
{
PlayerManagerMessaging.MessageType messageType = (PlayerManagerMessaging.MessageType)message.MessageType;
switch (messageType)
{
case PlayerManagerMessaging.MessageType.PlayerSlotStarted:
case PlayerManagerMessaging.MessageType.PlayerSlotClosed:
Update();
break;
}
}
else if (message.ChannelName == WorkflowManagerMessaging.CHANNEL)
{
WorkflowManagerMessaging.MessageType messageType = (WorkflowManagerMessaging.MessageType)message.MessageType;
switch (messageType)
{
case WorkflowManagerMessaging.MessageType.NavigationComplete:
Update();
break;
}
}
}
void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (message.ChannelName == PlayerManagerMessaging.CHANNEL)
{
PlayerManagerMessaging.MessageType messageType =
(PlayerManagerMessaging.MessageType)message.MessageType;
switch (messageType)
{
case PlayerManagerMessaging.MessageType.PlayerSlotStarted:
case PlayerManagerMessaging.MessageType.PlayerSlotClosed:
case PlayerManagerMessaging.MessageType.PlayerStarted:
case PlayerManagerMessaging.MessageType.PlayerStopped:
case PlayerManagerMessaging.MessageType.PlayerEnded:
case PlayerManagerMessaging.MessageType.PlayersMuted:
case PlayerManagerMessaging.MessageType.PlayersResetMute:
CheckUpdatePlayerConfigurationData();
break;
}
}
else if (message.ChannelName == PlayerContextManagerMessaging.CHANNEL)
{
PlayerContextManagerMessaging.MessageType messageType =
(PlayerContextManagerMessaging.MessageType)message.MessageType;
switch (messageType)
{
case PlayerContextManagerMessaging.MessageType.CurrentPlayerChanged:
case PlayerContextManagerMessaging.MessageType.PlayerSlotsChanged:
CheckUpdatePlayerConfigurationData();
break;
}
}
}
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 == ServerConnectionMessaging.CHANNEL)
{
ServerConnectionMessaging.MessageType messageType =
(ServerConnectionMessaging.MessageType)message.MessageType;
switch (messageType)
{
case ServerConnectionMessaging.MessageType.HomeServerAttached:
case ServerConnectionMessaging.MessageType.HomeServerConnected:
_updatePending = true; //Update all
break;
}
}
else if (message.ChannelName == ContentDirectoryMessaging.CHANNEL)
{
ContentDirectoryMessaging.MessageType messageType = (ContentDirectoryMessaging.MessageType)message.MessageType;
switch (messageType)
{
case ContentDirectoryMessaging.MessageType.ShareImportCompleted:
_importUpdatePending = true; //Update latest added
break;
case ContentDirectoryMessaging.MessageType.MediaItemChanged:
if ((ContentDirectoryMessaging.MediaItemChangeType)message.MessageData[ContentDirectoryMessaging.MEDIA_ITEM_CHANGE_TYPE] != ContentDirectoryMessaging.MediaItemChangeType.None)
{
_mediaItemUpdatePending = true;
}
break;
}
}
else if (message.ChannelName == SharesMessaging.CHANNEL)
{
SharesMessaging.MessageType messageType = (SharesMessaging.MessageType)message.MessageType;
switch (messageType)
{
case SharesMessaging.MessageType.ShareChanged:
case SharesMessaging.MessageType.ShareRemoved:
_updatePending = true; //Update all
break;
}
}
else if (message.ChannelName == PlayerManagerMessaging.CHANNEL)
{
PlayerManagerMessaging.MessageType messageType =
(PlayerManagerMessaging.MessageType)message.MessageType;
switch (messageType)
{
case PlayerManagerMessaging.MessageType.PlayerStopped:
case PlayerManagerMessaging.MessageType.PlayerEnded:
_playbackUpdatePending = true; //Update most played and last played
break;
}
}
}
private SystemMessage GetSystemMessageForMessageType(PlayerManagerMessaging.MessageType msgType)
{
IPlayerSlotController psc = Substitute.For <IPlayerSlotController>();
SystemMessage state = new SystemMessage(msgType)
{
ChannelName = "PlayerManager",
MessageData = { ["PlayerSlotController"] = psc }
};
return(state);
}
public void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (message.ChannelName == PlayerManagerMessaging.CHANNEL)
{
// React to player changes
PlayerManagerMessaging.MessageType messageType = (PlayerManagerMessaging.MessageType)message.MessageType;
IPlayerSlotController psc;
switch (messageType)
{
case PlayerManagerMessaging.MessageType.PlayerResumeState:
Logger.Debug("Player Resume");
//Resume();
break;
case PlayerManagerMessaging.MessageType.PlaybackStateChanged:
Logger.Debug("Player PlaybackStateChanged");
psc = (IPlayerSlotController)message.MessageData[PlayerManagerMessaging.PLAYER_SLOT_CONTROLLER];
IMediaPlaybackControl mpc = psc.CurrentPlayer as IMediaPlaybackControl;
if (mpc != null && mpc.IsPaused)
{
Pause();
}
else
{
Resume();
}
break;
case PlayerManagerMessaging.MessageType.PlayerError:
Logger.Error("Player Error");
break;
case PlayerManagerMessaging.MessageType.PlayerEnded:
case PlayerManagerMessaging.MessageType.PlayerStopped:
Logger.Debug("Player Stopped or Ended");
Stop();
break;
case PlayerManagerMessaging.MessageType.PlayerStarted:
Logger.Debug("Player Started");
break;
case PlayerManagerMessaging.MessageType.VolumeChanged:
Logger.Debug("Volume changed");
VolumeChanged();
break;
}
}
}
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.CurrentItemChange:
UpdateCurrentItem();
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_SHOW_PLAYLIST, true);
}
break;
// We don't need to track the PlayerSlotActivated or PlayerSlotsChanged messages, because all information
// we need is contained in the CurrentPlayer information
}
}
else if (message.ChannelName == PlayerContextManagerMessaging.CHANNEL)
{
PlayerContextManagerMessaging.MessageType messageType = (PlayerContextManagerMessaging.MessageType)message.MessageType;
switch (messageType)
{
case PlayerContextManagerMessaging.MessageType.CurrentPlayerChanged:
UpdatePlaylist();
break;
}
}
}
private void HandlePlayerMessage(PlayerManagerMessaging.MessageType message, IPlayerSlotController psc)
{
switch (message)
{
case PlayerManagerMessaging.MessageType.PlayerEnded:
case PlayerManagerMessaging.MessageType.PlayerStopped:
case PlayerManagerMessaging.MessageType.PlayerError:
IPlayerContext pc = PlayerContext.GetPlayerContext(psc);
if (pc != null)
{
onPlayerStopped(pc.CurrentMediaItem);
}
break;
}
}
protected void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (message.ChannelName == PlayerManagerMessaging.CHANNEL)
{
PlayerManagerMessaging.MessageType messageType =
(PlayerManagerMessaging.MessageType)message.MessageType;
switch (messageType)
{
case PlayerManagerMessaging.MessageType.PlayerSlotStarted:
case PlayerManagerMessaging.MessageType.PlayerSlotClosed:
Update();
break;
}
}
}
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;
}
}
}
public static void OnMessageReceived(SystemMessage message)
{
// React to player changes
PlayerManagerMessaging.MessageType messageType = (PlayerManagerMessaging.MessageType)message.MessageType;
IPlayerSlotController psc;
switch (messageType)
{
case PlayerManagerMessaging.MessageType.PlayerResumeState:
Logger.Debug("WifiRemote: Player Resume");
//Resume();
break;
case PlayerManagerMessaging.MessageType.PlaybackStateChanged:
Logger.Debug("WifiRemote: Playback State Changed");
SendMessageToAllClients.Send(WifiRemotePlugin.MessageStatus, ref SocketServer.Instance.connectedSockets);
break;
case PlayerManagerMessaging.MessageType.PlayerError:
Logger.Error("WifiRemote: Player Error");
break;
case PlayerManagerMessaging.MessageType.PlayerEnded:
case PlayerManagerMessaging.MessageType.PlayerStopped:
Logger.Debug("WifiRemote: Player Stopped or Ended");
SendMessageToAllClients.Send(WifiRemotePlugin.MessageStatus, ref SocketServer.Instance.connectedSockets);
NowPlayingUpdater.Stop();
break;
case PlayerManagerMessaging.MessageType.PlayerStarted:
Logger.Debug("WifiRemote: Player Started");
SendMessageToAllClients.Send(WifiRemotePlugin.MessageStatus, ref SocketServer.Instance.connectedSockets);
NowPlayingUpdater.Start();
break;
case PlayerManagerMessaging.MessageType.VolumeChanged:
Logger.Debug("WifiRemote: Volume changed");
SendMessageToAllClients.Send(new MessageVolume(), ref SocketServer.Instance.connectedSockets);
break;
}
}
private void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (message.ChannelName == PlayerManagerMessaging.CHANNEL)
{
PlayerManagerMessaging.MessageType messageType = (PlayerManagerMessaging.MessageType)message.MessageType;
switch (messageType)
{
case PlayerManagerMessaging.MessageType.PlayerStarted:
StartScrobble(message);
break;
case PlayerManagerMessaging.MessageType.PlayerResumeState:
SaveResumePosition(message);
break;
case PlayerManagerMessaging.MessageType.PlayerError:
case PlayerManagerMessaging.MessageType.PlayerEnded:
case PlayerManagerMessaging.MessageType.PlayerStopped:
StopScrobble();
break;
}
}
}
void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (message.ChannelName == WorkflowManagerMessaging.CHANNEL)
{
// Adjust our knowledge about the currently opened FSC/CP state if the user switches to one of them
WorkflowManagerMessaging.MessageType messageType = (WorkflowManagerMessaging.MessageType)message.MessageType;
switch (messageType)
{
case WorkflowManagerMessaging.MessageType.StatesPopped:
ICollection <Guid> statesRemoved = new List <Guid>(
((IDictionary <Guid, NavigationContext>)message.MessageData[WorkflowManagerMessaging.CONTEXTS]).Keys);
HandleStatesRemovedFromWorkflowStack(statesRemoved);
break;
case WorkflowManagerMessaging.MessageType.StatePushed:
NavigationContext context = (NavigationContext)message.MessageData[WorkflowManagerMessaging.CONTEXT];
Guid stateId = context.WorkflowState.StateId;
HandleWorkflowStatePushed(stateId);
break;
}
}
else if (message.ChannelName == PlayerManagerMessaging.CHANNEL)
{
// React to player changes
PlayerManagerMessaging.MessageType messageType = (PlayerManagerMessaging.MessageType)message.MessageType;
IPlayerSlotController psc;
switch (messageType)
{
case PlayerManagerMessaging.MessageType.PlayerResumeState:
psc = (IPlayerSlotController)message.MessageData[PlayerManagerMessaging.PLAYER_SLOT_CONTROLLER];
IResumeState resumeState = (IResumeState)message.MessageData[PlayerManagerMessaging.KEY_RESUME_STATE];
Guid mediaItemId = (Guid)message.MessageData[PlayerManagerMessaging.KEY_MEDIAITEM_ID];
HandleResumeInfo(psc, mediaItemId, resumeState);
break;
case PlayerManagerMessaging.MessageType.PlayerError:
case PlayerManagerMessaging.MessageType.PlayerEnded:
psc = (IPlayerSlotController)message.MessageData[PlayerManagerMessaging.PLAYER_SLOT_CONTROLLER];
HandlePlayerEnded(psc);
break;
case PlayerManagerMessaging.MessageType.PlayerStopped:
psc = (IPlayerSlotController)message.MessageData[PlayerManagerMessaging.PLAYER_SLOT_CONTROLLER];
HandlePlayerStopped(psc);
break;
case PlayerManagerMessaging.MessageType.RequestNextItem:
psc = (IPlayerSlotController)message.MessageData[PlayerManagerMessaging.PLAYER_SLOT_CONTROLLER];
HandleRequestNextItem(psc);
break;
}
CleanupPlayerContexts();
CheckMediaWorkflowStates_NoLock(); // Primary player could have been changed or closed or CP player could have been closed
}
else if (message.ChannelName == PlayerContextManagerMessaging.CHANNEL)
{
// React to internal player context manager changes
PlayerContextManagerMessaging.MessageType messageType = (PlayerContextManagerMessaging.MessageType)message.MessageType;
switch (messageType)
{
case PlayerContextManagerMessaging.MessageType.UpdatePlayerRolesInternal:
PlayerContext newCurrentPlayer = (PlayerContext)message.MessageData[PlayerContextManagerMessaging.NEW_CURRENT_PLAYER_CONTEXT];
PlayerContext newAudioPlayer = (PlayerContext)message.MessageData[PlayerContextManagerMessaging.NEW_AUDIO_PLAYER_CONTEXT];
HandleUpdatePlayerRoles(newCurrentPlayer, newAudioPlayer);
break;
// PlayerContextManagerMessaging.MessageType.CurrentPlayerChanged not handled here
}
}
}
void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (message.ChannelName == WorkflowManagerMessaging.CHANNEL)
{
// Adjust our knowledge about the currently opened FSC/CP state if the user switches to one of them
WorkflowManagerMessaging.MessageType messageType =
(WorkflowManagerMessaging.MessageType)message.MessageType;
switch (messageType)
{
case WorkflowManagerMessaging.MessageType.StatesPopped:
ICollection <Guid> statesRemoved = new List <Guid>(
((IDictionary <Guid, NavigationContext>)message.MessageData[WorkflowManagerMessaging.CONTEXTS]).Keys);
HandleStatesRemovedFromWorkflowStack(statesRemoved);
break;
case WorkflowManagerMessaging.MessageType.StatePushed:
NavigationContext context = (NavigationContext)message.MessageData[WorkflowManagerMessaging.CONTEXT];
Guid stateId = context.WorkflowState.StateId;
HandleWorkflowStatePushed(stateId);
break;
}
}
else if (message.ChannelName == PlayerManagerMessaging.CHANNEL)
{
// React to player changes
PlayerManagerMessaging.MessageType messageType =
(PlayerManagerMessaging.MessageType)message.MessageType;
IPlayerSlotController psc;
uint activationSequence;
switch (messageType)
{
case PlayerManagerMessaging.MessageType.PlayerError:
case PlayerManagerMessaging.MessageType.PlayerEnded:
psc = (IPlayerSlotController)message.MessageData[PlayerManagerMessaging.PLAYER_SLOT_CONTROLLER];
activationSequence = (uint)message.MessageData[PlayerManagerMessaging.ACTIVATION_SEQUENCE];
HandlePlayerEnded(psc, activationSequence);
break;
case PlayerManagerMessaging.MessageType.PlayerStopped:
psc = (IPlayerSlotController)message.MessageData[PlayerManagerMessaging.PLAYER_SLOT_CONTROLLER];
activationSequence = (uint)message.MessageData[PlayerManagerMessaging.ACTIVATION_SEQUENCE];
HandlePlayerStopped(psc, activationSequence);
break;
case PlayerManagerMessaging.MessageType.RequestNextItem:
psc = (IPlayerSlotController)message.MessageData[PlayerManagerMessaging.PLAYER_SLOT_CONTROLLER];
activationSequence = (uint)message.MessageData[PlayerManagerMessaging.ACTIVATION_SEQUENCE];
HandleRequestNextItem(psc, activationSequence);
break;
case PlayerManagerMessaging.MessageType.PlayerSlotsChanged:
HandlePlayerSlotsChanged();
break;
}
CheckCurrentPlayerSlot(); // Current player could have been closed
CheckMediaWorkflowStates_NoLock(); // Primary player could have been changed or closed or CP player could have been closed
}
else if (message.ChannelName == PlayerContextManagerMessaging.CHANNEL)
{
// React to internal player context manager changes
PlayerContextManagerMessaging.MessageType messageType =
(PlayerContextManagerMessaging.MessageType)message.MessageType;
switch (messageType)
{
case PlayerContextManagerMessaging.MessageType.UpdatePlayerRolesInternal:
int newCurrentPlayerIndex = (int)message.MessageData[PlayerContextManagerMessaging.CURRENT_PLAYER_INDEX];
int newAudioPlayerIndex = (int)message.MessageData[PlayerContextManagerMessaging.AUDIO_PLAYER_INDEX];
HandlePlayerRolesChanged(newCurrentPlayerIndex, newAudioPlayerIndex);
break;
// PlayerContextManagerMessaging.MessageType.CurrentPlayerChanged not handled here
}
}
}
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);
}
}
}
}
