void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
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))
{
OnTvServerStateChanged(states[TvServerState.STATE_ID] as TvServerState);
}
}
}
}
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 OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (message.ChannelName == SharesMessaging.CHANNEL)
{
IContentDirectory cd = ContentDirectory;
SharesMessaging.MessageType messageType =
(SharesMessaging.MessageType) message.MessageType;
IImporterWorker importerWorker = ServiceRegistration.Get<IImporterWorker>();
Share share;
switch (messageType)
{
case SharesMessaging.MessageType.ShareAdded:
share = (Share) message.MessageData[SharesMessaging.SHARE];
if (cd != null)
cd.RegisterShareAsync(share);
importerWorker.ScheduleImport(share.BaseResourcePath, share.MediaCategories, true);
break;
case SharesMessaging.MessageType.ShareRemoved:
share = (Share) message.MessageData[SharesMessaging.SHARE];
importerWorker.CancelJobsForPath(share.BaseResourcePath);
if (cd != null)
cd.RemoveShareAsync(share.ShareId);
break;
case SharesMessaging.MessageType.ShareChanged:
RelocationMode relocationMode = (RelocationMode) message.MessageData[SharesMessaging.RELOCATION_MODE];
share = (Share) message.MessageData[SharesMessaging.SHARE];
importerWorker.CancelJobsForPath(share.BaseResourcePath);
if (cd == null)
{
ISettingsManager settingsManager = ServiceRegistration.Get<ISettingsManager>();
ServerConnectionSettings settings = settingsManager.Load<ServerConnectionSettings>();
RelocationMode oldMode;
if (settings.CachedSharesUpdates.TryGetValue(share.ShareId, out oldMode) && oldMode == RelocationMode.ClearAndReImport)
// ClearAndReimport is stronger than Relocate, use ClearAndReImport
relocationMode = oldMode;
settings.CachedSharesUpdates[share.ShareId] = relocationMode;
settingsManager.Save(settings);
}
else
{
cd.UpdateShareAsync(share.ShareId, share.BaseResourcePath, share.Name, share.UseShareWatcher, share.MediaCategories, relocationMode);
switch (relocationMode)
{
case RelocationMode.ClearAndReImport:
importerWorker.ScheduleImport(share.BaseResourcePath, share.MediaCategories, true);
break;
case RelocationMode.Relocate:
importerWorker.ScheduleRefresh(share.BaseResourcePath, share.MediaCategories, true);
break;
}
}
break;
case SharesMessaging.MessageType.ReImportShare:
share = (Share) message.MessageData[SharesMessaging.SHARE];
importerWorker.ScheduleRefresh(share.BaseResourcePath, share.MediaCategories, true);
break;
}
}
else if (message.ChannelName == ImporterWorkerMessaging.CHANNEL)
{
IContentDirectory cd = ContentDirectory;
ImporterWorkerMessaging.MessageType messageType = (ImporterWorkerMessaging.MessageType) message.MessageType;
switch (messageType)
{
case ImporterWorkerMessaging.MessageType.ImportStarted:
case ImporterWorkerMessaging.MessageType.ImportCompleted:
if (cd == null)
break;
ResourcePath path = (ResourcePath) message.MessageData[ImporterWorkerMessaging.RESOURCE_PATH];
ILocalSharesManagement lsm = ServiceRegistration.Get<ILocalSharesManagement>();
ICollection<Share> shares = lsm.Shares.Values;
Share share = shares.BestContainingPath(path);
if (share == null)
break;
if (messageType == ImporterWorkerMessaging.MessageType.ImportStarted)
cd.ClientStartedShareImportAsync(share.ShareId);
else
cd.ClientCompletedShareImportAsync(share.ShareId);
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(ShareImportServerState.STATE_ID))
{
ShareImportServerState importState = states[ShareImportServerState.STATE_ID] as ShareImportServerState;
if (importState != null)
{
List<ShareImportState> shareStates = new List<ShareImportState>(importState.Shares);
lock (_syncObj)
{
UpdateCurrentlyImportingShares(shareStates.Where(s => s.IsImporting).Select(s => s.ShareId).ToList());
UpdateCurrentlyImportingSharesProgresses(shareStates.Where(s => s.IsImporting).ToDictionary(s => s.ShareId, s => s.Progress));
}
}
}
else if (states != null && states.ContainsKey(DatabaseUpgradeServerState.STATE_ID))
{
DatabaseUpgradeServerState upgradeState = states[DatabaseUpgradeServerState.STATE_ID] as DatabaseUpgradeServerState;
if (upgradeState != null && !upgradeState.IsUpgrading && upgradeState.Progress == 100)
{
ServerConnectionMessaging.SendServerConnectionStateChangedMessage(ServerConnectionMessaging.MessageType.HomeServerDisconnected);
ServerConnectionMessaging.SendServerConnectionStateChangedMessage(ServerConnectionMessaging.MessageType.HomeServerConnected);
}
}
}
}
}
