private void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (!IsSystemActive())
{
return;
}
bool forceMenuUpdate = false;
if (message.ChannelName == ServerConnectionMessaging.CHANNEL)
{
ServerConnectionMessaging.MessageType messageType = (ServerConnectionMessaging.MessageType)message.MessageType;
switch (messageType)
{
case ServerConnectionMessaging.MessageType.HomeServerConnected:
case ServerConnectionMessaging.MessageType.HomeServerDisconnected:
case ServerConnectionMessaging.MessageType.HomeServerAttached:
case ServerConnectionMessaging.MessageType.HomeServerDetached:
forceMenuUpdate = true;
break;
}
}
InitMenu(force: forceMenuUpdate);
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 == ServerConnectionMessaging.CHANNEL)
{
ServerConnectionMessaging.MessageType type = (ServerConnectionMessaging.MessageType)message.MessageType;
switch (type)
{
case ServerConnectionMessaging.MessageType.HomeServerConnected:
Enable(true);
RefreshNetworkNeighborhoodResourceProviderSettings();
break;
case ServerConnectionMessaging.MessageType.HomeServerDisconnected:
Enable(false);
break;
case ServerConnectionMessaging.MessageType.HomeServerAttached:
RegisterService();
Visible(true);
break;
case ServerConnectionMessaging.MessageType.HomeServerDetached:
Visible(false);
break;
}
}
}
/// <summary>
/// Receive Server change messages from the <see cref="IServerConnectionManager"/> or from the <see cref="ILocalization"/> service.
/// </summary>
public void Receive(SystemMessage message)
{
if (message.ChannelName == ServerConnectionMessaging.CHANNEL)
{
var connectionType = (ServerConnectionMessaging.MessageType)message.MessageType;
switch (connectionType)
{
case ServerConnectionMessaging.MessageType.HomeServerAttached:
case ServerConnectionMessaging.MessageType.HomeServerConnected:
case ServerConnectionMessaging.MessageType.HomeServerDetached:
case ServerConnectionMessaging.MessageType.HomeServerDisconnected:
_serverConnectionStatus = connectionType;
break;
}
UpdateServerStatus();
}
else if (message.ChannelName == LocalizationMessaging.CHANNEL)
{
if (((LocalizationMessaging.MessageType)message.MessageType) ==
LocalizationMessaging.MessageType.LanguageChanged)
{
UpdateServerStatus();
}
}
}
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;
}
}
}
protected 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:
FireStateChanged();
break;
}
}
else if (message.ChannelName == ContentDirectoryMessaging.CHANNEL)
{
ContentDirectoryMessaging.MessageType messageType = (ContentDirectoryMessaging.MessageType)message.MessageType;
switch (messageType)
{
case ContentDirectoryMessaging.MessageType.RegisteredSharesChanged:
FireStateChanged();
break;
}
}
else if (message.ChannelName == SharesMessaging.CHANNEL)
{
SharesMessaging.MessageType messageType = (SharesMessaging.MessageType)message.MessageType;
switch (messageType)
{
case SharesMessaging.MessageType.ShareAdded:
case SharesMessaging.MessageType.ShareRemoved:
FireStateChanged();
break;
}
}
}
public AppController()
{
_synchronizationContext = SynchronizationContext.Current;
Clients = new ObservableCollectionMt <ClientData>();
_serverConnectionStatus = ServerConnectionMessaging.MessageType.HomeServerDisconnected;
// Register at message channels
ServiceRegistration.Get <IMessageBroker>().RegisterMessageReceiver(ServerConnectionMessaging.CHANNEL, this);
ServiceRegistration.Get <IMessageBroker>().RegisterMessageReceiver(LocalizationMessaging.CHANNEL, this);
}
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 void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (message.ChannelName == NotificationServiceMessaging.CHANNEL)
{
INotification notification = (INotification)message.MessageData[NotificationServiceMessaging.NOTIFICATION];
NotificationServiceMessaging.MessageType messageType = (NotificationServiceMessaging.MessageType)message.MessageType;
if (messageType == NotificationServiceMessaging.MessageType.NotificationDequeued ||
messageType == NotificationServiceMessaging.MessageType.NotificationRemoved)
{
lock (_syncObj)
if (notification == _queuedNotification)
{
_queuedNotification = null;
}
}
}
// Check setting which prevents the listener service to pop up server availability messages
ISettingsManager settingsManager = ServiceRegistration.Get <ISettingsManager>();
SkinBaseSettings settings = settingsManager.Load <SkinBaseSettings>();
if (!settings.EnableServerListener)
{
RemoveNotification();
return;
}
if (message.ChannelName == ServerConnectionMessaging.CHANNEL)
{
ServerConnectionMessaging.MessageType messageType =
(ServerConnectionMessaging.MessageType)message.MessageType;
switch (messageType)
{
case ServerConnectionMessaging.MessageType.AvailableServersChanged:
bool serversWereAdded = (bool)message.MessageData[ServerConnectionMessaging.SERVERS_WERE_ADDED];
if (serversWereAdded)
{
QueueNotification();
}
else
{
ICollection <ServerDescriptor> servers = (ICollection <ServerDescriptor>)message.MessageData[ServerConnectionMessaging.AVAILABLE_SERVERS];
if (servers.Count == 0)
{
// No servers available any more
RemoveNotification();
}
}
break;
case ServerConnectionMessaging.MessageType.HomeServerAttached:
// Home server was attached outside the notification handler
RemoveNotification();
break;
}
}
}
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 == ContentDirectoryMessaging.CHANNEL)
{
ContentDirectoryMessaging.MessageType messageType = (ContentDirectoryMessaging.MessageType)message.MessageType;
switch (messageType)
{
case ContentDirectoryMessaging.MessageType.RegisteredSharesChanged:
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;
}
}
}
private void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (message.ChannelName == ServerConnectionMessaging.CHANNEL)
{
ServerConnectionMessaging.MessageType type = (ServerConnectionMessaging.MessageType)message.MessageType;
switch (type)
{
case ServerConnectionMessaging.MessageType.HomeServerConnected:
SyncWithServer(Load());
break;
}
}
}
protected virtual void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (message.ChannelName == ServerConnectionMessaging.CHANNEL)
{
ServerConnectionMessaging.MessageType messageType = (ServerConnectionMessaging.MessageType)message.MessageType;
switch (messageType)
{
case ServerConnectionMessaging.MessageType.HomeServerConnected:
case ServerConnectionMessaging.MessageType.HomeServerDisconnected:
Update();
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];
var type = ExamineVolume(drive);
if (_removableMediaItems.TryGetValue(drive, out var items))
{
PlayItemsModel.AddOrUpdateRemovableMediaItems(items);
}
RemovableMediaManagerSettings settings = ServiceRegistration.Get <ISettingsManager>().Load <RemovableMediaManagerSettings>();
if (settings.AutoPlay == AutoPlayType.AutoPlay)
{
IPlayerContextManager pcm = ServiceRegistration.Get <IPlayerContextManager>();
if (!pcm.IsFullscreenContentWorkflowStateActive)
{
CheckAutoPlay(drive, type);
}
}
}
else if (messageType == RemovableMediaMessaging.MessageType.MediaRemoved)
{
string drive = (string)message.MessageData[RemovableMediaMessaging.DRIVE_LETTER];
IEnumerable <MediaItem> items;
if (_removableMediaItems.TryRemove(drive, out items))
{
PlayItemsModel.RemoveRemovableMediaItems(items);
}
if (_removableMediaItems.TryRemove(drive + @"\", out items))
{
PlayItemsModel.RemoveRemovableMediaItems(items);
}
}
}
else if (message.ChannelName == ServerConnectionMessaging.CHANNEL)
{
ServerConnectionMessaging.MessageType messageType = (ServerConnectionMessaging.MessageType)message.MessageType;
if (messageType == ServerConnectionMessaging.MessageType.HomeServerConnected && _runStartupCheck)
{
_runStartupCheck = false;
StartupCheck();
}
}
}
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;
}
}
}
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;
}
}
}
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 == 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 == 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;
}
}
}
}
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();
UpdatePlaylists(false);
break;
case ServerConnectionMessaging.MessageType.HomeServerDisconnected:
if (!NavigateBackToOverview())
{
UpdateProperties();
UpdatePlaylists(false);
}
break;
}
}
else if (message.ChannelName == ContentDirectoryMessaging.CHANNEL)
{
ContentDirectoryMessaging.MessageType messageType =
(ContentDirectoryMessaging.MessageType)message.MessageType;
switch (messageType)
{
case ContentDirectoryMessaging.MessageType.PlaylistsChanged:
UpdatePlaylists(false);
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.HomeServerConnected:
case ServerConnectionMessaging.MessageType.HomeServerDisconnected:
Update();
break;
}
}
else if (message.ChannelName == ContentDirectoryMessaging.CHANNEL)
{
ContentDirectoryMessaging.MessageType messageType = (ContentDirectoryMessaging.MessageType)message.MessageType;
switch (messageType)
{
case ContentDirectoryMessaging.MessageType.PlaylistsChanged:
Update();
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.AvailableServersChanged:
ICollection <ServerDescriptor> availableServers = (ICollection <ServerDescriptor>)
message.MessageData[ServerConnectionMessaging.AVAILABLE_SERVERS];
SynchronizeAvailableServers();
Mode mode;
lock (_syncObj)
mode = _mode;
if (mode == Mode.AttachToServer)
{
if (_autoCloseOnNoServer && availableServers.Count == 0)
{
LeaveConfiguration();
return;
}
}
break;
}
}
else if (message.ChannelName == DialogManagerMessaging.CHANNEL)
{
DialogManagerMessaging.MessageType messageType = (DialogManagerMessaging.MessageType)message.MessageType;
if (messageType == DialogManagerMessaging.MessageType.DialogClosed)
{
Guid dialogHandle = (Guid)message.MessageData[DialogManagerMessaging.DIALOG_HANDLE];
bool leaveConfiguration = false;
bool doDetach = false;
lock (_syncObj)
if (_attachInfoDialogHandle == dialogHandle)
{
_attachInfoDialogHandle = null;
leaveConfiguration = true;
}
else if (_detachConfirmDialogHandle == dialogHandle)
{
DialogResult dialogResult = (DialogResult)message.MessageData[DialogManagerMessaging.DIALOG_RESULT];
_detachConfirmDialogHandle = Guid.Empty;
if (dialogResult == DialogResult.Yes)
{
doDetach = true;
}
leaveConfiguration = true;
}
// Do the next two statements outside our lock
if (doDetach)
{
DoDetachFromHomeServer();
}
if (leaveConfiguration)
{
LeaveConfiguration();
}
}
}
}
