public void SetNewHomeServer(string backendServerSystemId) { ServiceRegistration.Get<ILogger>().Info("ServerConnectionManager: Attaching to MediaPortal backend server '{0}'", backendServerSystemId); ServiceRegistration.Get<ILogger>().Debug("ServerConnectionManager: Stopping to watch for MediaPortal servers"); lock (_syncObj) if (_serverWatcher != null) { _serverWatcher.Stop(); _serverWatcher = null; } ServiceRegistration.Get<ILogger>().Debug("ServerConnectionManager: Building UPnP control point for communication with the new home server"); UPnPClientControlPoint cp; lock (_syncObj) cp = _controlPoint; if (cp != null) cp.Stop(); // Must be outside the lock - sends messages lock (_syncObj) { ISettingsManager settingsManager = ServiceRegistration.Get<ISettingsManager>(); ServerConnectionSettings settings = settingsManager.Load<ServerConnectionSettings>(); // Here, we only set the system ID of the new home server. The server's system ID will remain in the settings // until method SetNewHomeServer is called again. settings.HomeServerSystemId = backendServerSystemId; settingsManager.Save(settings); _controlPoint = BuildClientControlPoint(backendServerSystemId); } _controlPoint.Start(); // Outside the lock ServerConnectionMessaging.SendServerConnectionStateChangedMessage(ServerConnectionMessaging.MessageType.HomeServerAttached); }
void OnBackendServerDisconnected(DeviceConnection connection) { lock (_syncObj) _isHomeServerConnected = false; IImporterWorker importerWorker = ServiceRegistration.Get<IImporterWorker>(); importerWorker.Suspend(); UpdateCurrentlyImportingShares(null); // Mark all shares as not being imported ServerConnectionMessaging.SendServerConnectionStateChangedMessage(ServerConnectionMessaging.MessageType.HomeServerDisconnected); }
void OnBackendServerConnected(DeviceConnection connection) { ServerDescriptor serverDescriptor = ServerDescriptor.GetMPBackendServerDescriptor(connection.RootDescriptor); if (serverDescriptor == null) { ServiceRegistration.Get<ILogger>().Warn("ServerConnectionManager: Could not connect to home server - Unable to verify UPnP root descriptor"); return; } SystemName preferredLink = serverDescriptor.GetPreferredLink(); ServiceRegistration.Get<ILogger>().Info("ServerConnectionManager: Connected to home server '{0}' at host '{1}' (IP address: '{2}')", serverDescriptor.MPBackendServerUUID, preferredLink.HostName, preferredLink.Address); lock (_syncObj) { _isHomeServerConnected = true; SaveLastHomeServerData(serverDescriptor); } ServerConnectionMessaging.SendServerConnectionStateChangedMessage(ServerConnectionMessaging.MessageType.HomeServerConnected); //ServiceRegistration.Get<IThreadPool>().Add(CompleteServerConnection); _ = CompleteServerConnectionAsync(); }
public void DetachFromHomeServer() { ISettingsManager settingsManager = ServiceRegistration.Get<ISettingsManager>(); ServerConnectionSettings settings = settingsManager.Load<ServerConnectionSettings>(); ServiceRegistration.Get<ILogger>().Info("ServerConnectionManager: Detaching from home server '{0}'", settings.HomeServerSystemId); ServiceRegistration.Get<ILogger>().Debug("ServerConnectionManager: Clearing pending import jobs and suspending importer worker"); IImporterWorker importerWorker = ServiceRegistration.Get<IImporterWorker>(); importerWorker.Suspend(); importerWorker.CancelPendingJobs(); ServiceRegistration.Get<ILogger>().Debug("ServerConnectionManager: Notifying the MediaPortal server about the detachment"); UPnPServerControllerServiceProxy sc = ServerControllerServiceProxy; ISystemResolver systemResolver = ServiceRegistration.Get<ISystemResolver>(); if (sc != null) try { sc.DetachClient(systemResolver.LocalSystemId); sc.AttachedClientsChanged -= OnAttachedClientsChanged; sc.ConnectedClientsChanged -= OnConnectedClientsChanged; } catch (Exception e) { ServiceRegistration.Get<ILogger>().Warn("ServerConnectionManager: Error detaching from home server '{0}'", e, HomeServerSystemId); } UPnPContentDirectoryServiceProxy cd = ContentDirectoryServiceProxy; if (cd != null) try { cd.PlaylistsChanged -= OnContentDirectoryPlaylistsChanged; cd.MIATypeRegistrationsChanged -= OnContentDirectoryMIATypeRegistrationsChanged; cd.RegisteredSharesChangeCounterChanged -= OnRegisteredSharesChangeCounterChanged; } catch (Exception e) { ServiceRegistration.Get<ILogger>().Warn("ServerConnectionManager: Error unregistering from state variable change events", e); } ServiceRegistration.Get<ILogger>().Debug("ServerConnectionManager: Closing server connection"); UPnPClientControlPoint cp; lock (_syncObj) cp = _controlPoint; if (cp != null) cp.Stop(); // Must be outside the lock - sends messages lock (_syncObj) { settings.HomeServerSystemId = null; settings.LastHomeServerName = null; settings.LastHomeServerSystem = null; settingsManager.Save(settings); _controlPoint = null; } UpdateCurrentlyImportingShares(null); // Mark all shares as not being imported ServerConnectionMessaging.SendServerConnectionStateChangedMessage(ServerConnectionMessaging.MessageType.HomeServerDetached); ServiceRegistration.Get<ILogger>().Debug("ServerConnectionManager: Starting to watch for MediaPortal servers"); if (_serverWatcher == null) { lock (_syncObj) _serverWatcher = BuildServerWatcher(); _serverWatcher.Start(); // Outside the lock } }
static void OnConnectedClientsChanged() { ServerConnectionMessaging.SendClientConnectionStateChangedMessage(); }
static void OnAvailableBackendServersChanged(ICollection<ServerDescriptor> allAvailableServers, bool serversWereAdded) { ServerConnectionMessaging.SendAvailableServersChangedMessage(allAvailableServers, serversWereAdded); }
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); } } } } }