private void M_deviceSocketConnection_OnMessageReceived(object sender, BaseMessage e)
{
var dontWait = SimpleDispatcher.RunAsync(delegate
{
try
{
if (e is MothershipSendCardMessage)
{
var cardMessage = e as MothershipSendCardMessage;
var card = CrossPlatformCardViewModel.CreateInstanceFunction();
card.CardIdentifier = cardMessage.CardIdentifier;
card.CardJson = cardMessage.CardJson;
MainViewModel.Current.AddCard(card);
}
else if (e is ClientNameAssignedMessage)
{
MainViewModel.Current.Name = (e as ClientNameAssignedMessage).ClientName;
m_onNameAssignedAction?.Invoke();
}
else if (e is MothershipDisconnectedMessage)
{
OnConnectionClosed?.Invoke("Mothership has been disconnected");
}
}
catch { }
});
}
protected DynamicActivityMachine(string name, SimpleDispatcher dispatcher)
: base(name)
{
InitializeComponents();
_hasLocalDispatcher = false;
Dispatcher = dispatcher;
}
private void DeviceSocketConnection_OnMessageReceived(object sender, BaseMessage e)
{
var dontWait = SimpleDispatcher.RunAsync(delegate
{
OnMessageReceived(e);
});
}
public void Stop()
{
CefRuntime.PostTask(CefThreadId.UI, BrowserTask.Create(() =>
{
if (!isMultiThreadedMessageLoop)
{
CefRuntime.QuitMessageLoop();
}
}));
dispatcher.PostTask(() =>
{
CefRuntime.Shutdown();
});
dispatcher.Shutdown();
int browserMapCount = browserMap.Count;
if (browserMapCount != 0)
{
throw new CefRuntimeException(String.Format(
"After shutting down {0} browser instances were undisposed",
browserMapCount));
}
dispatcher = null;
}
protected override void OnStartup(StartupEventArgs startupEventArgs)
{
base.OnStartup(startupEventArgs);
var mainWindow = new MainWindow();
Thread.CurrentThread.Name = "main";
Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
try
{
var assemblyLocation = Assembly.GetExecutingAssembly().Location;
var settingsLocation = Path.Combine(Directory.GetParent(assemblyLocation) !.Parent !.FullName, "settings.json");
var interactionService = new InteractionService(mainWindow);
var dispatcher = new SimpleDispatcher(Dispatcher.CurrentDispatcher);
var core = new Core.Core(new FileInfo(settingsLocation), interactionService, dispatcher);
var vm = core.GetViewModel();
void ShowUpdateNotification(string message)
{
dispatcher.ExecuteSynchronized(() =>
{
vm.AddNotification(new NotificationEvent(message));
});
}
UpdateHelper.Update(ShowUpdateNotification);
mainWindow.DataContext = vm;
mainWindow.Show();
core.Dispose();
}
catch (Exception e)
{
_logger.Error(e);
throw;
}
}
private void Dispose()
{
lock (_disposeLock)
{
if (_disposed)
{
return;
}
_disposed = true;
}
if (_dispatcher != null)
{
_dispatcher.Dispose();
}
_dispatcher = null;
try
{
_waitForFinishEvent.Dispose();
}
catch (ObjectDisposedException)
{
//nothing to do. wait handle was disposed
}
LogService.Log(LogType.System, LogMessageType.Debug, GetType().Name,
string.Format(CultureInfo.InvariantCulture, "{0} is disposed.", Name));
}
private void DeviceSocketConnection_OnSocketClosed(object sender, EventArgs e)
{
var dontWait = SimpleDispatcher.RunAsync(async delegate
{
await new MessageDialog("Connection closed. Please re-open the app.").ShowAsync();
Application.Current.Exit();
});
}
public BrowserManager()
{
browserMap = new Dictionary <int, BrowserWrapper>();
dispatcher = new SimpleDispatcher();
dispatcher.Start();
PluginManager = new BrowserPluginManager();
}
public static SimpleDispatcher ExtractDispatcher(DynamicConfiguration config)
{
SimpleDispatcher dispatcher = null;
if (config.HasDataKey("Dispatcher"))
{
dispatcher = config.Data.Dispatcher as SimpleDispatcher;
}
return(dispatcher);
}
public void Publish_calls_the_method_on_subscriber()
{
var simplePublishWay = new SimpleDispatcher();
var message = new TestMessage();
var handler = new TestHandler();
simplePublishWay.Invoke(message, handler);
Assert.That(handler.TestMessage, Is.SameAs(message));
}
public TrayMover(string srcName, string dstName)
{
Name = "TrayMover(" + srcName + "->" + dstName + ")";
IsSynchronous = false;
LockResources = true;
SourceLockOwner = this;
CompletionCause = CompletionCause.Pending;
WaitWatcher = new MicroStopwatch();
_dispatcher = new SimpleDispatcher(Name);
}
/// <summary>
/// Create a new SimpleDispatcher and start running executables.
/// </summary>
public virtual void Start()
{
lock (_runLock)
{
if (!IsRunning)
{
_dispatcher = new SimpleDispatcher(GetType().Name);
IsRunning = true;
}
}
}
public void Invokes_until_appropriate_subdispatcher_found()
{
var denyDispatcher = new SimpleDispatcher(new Rule((message, handler) => false));
var successDispatcher = new SimpleDispatcher(new Rule((message, handler) => true));
var dispatcher = new CompositeDispatcher(new IDispatcher[] {denyDispatcher, successDispatcher});
var testHandler = new TestHandler<TestMessage>();
dispatcher.Invoke(new TestMessage(), testHandler);
Assert.That(testHandler.WasCalledOnce, Is.True);
}
public void Invokation_should_not_be_perfomed_twice()
{
var successDispatcher1 = new SimpleDispatcher(new Rule((message, handler) => true));
var successDispatcher2 = new SimpleDispatcher(new Rule((message, handler) => true));
var dispatcher = new CompositeDispatcher(new IDispatcher[] { successDispatcher1, successDispatcher2 });
var testHandler = new TestHandler<TestMessage>();
dispatcher.Invoke(new TestMessage(), testHandler);
Assert.That(testHandler.WasCalled, Is.EqualTo(1));
}
public void Publish_will_send_the_message_to_listner()
{
var assignee = new SimpleAssignee();
var publishWay = new SimpleDispatcher();
var handler = new TestHandler();
var message = new TestMessage();
var publisher = new Publisher(assignee, publishWay);
assignee.Subscribe(handler);
publisher.Publish(message);
Assert.That(handler.TestMessage, Is.SameAs(message));
}
private void M_deviceSocketConnection_OnSocketClosed(object sender, EventArgs e)
{
m_deviceSocketConnection.OnSocketClosed -= M_deviceSocketConnection_OnSocketClosed;
m_deviceSocketConnection.OnMessageReceived -= M_deviceSocketConnection_OnMessageReceived;
m_deviceSocketConnection = null;
var dontWait = SimpleDispatcher.RunAsync(delegate
{
try
{
OnConnectionClosed?.Invoke("Socket closed");
}
catch { }
});
}
protected void Teardown()
{
// Only dispose the dispatcher if it was created here.
if (_hasLocalDispatcher)
{
// We are here because the FinalNode's ExitBehavior is running on the Dispatcher.
// Attempting to dispose of the Dispatcher from the final executable using the Dispatcher's
// own thread will cause the Dispatcher to kill (abort) it's thread.
// That thread abort can be avoided by giving the Dispatcher cleanup to a different thread,
// which allows the currently executing ExitBehavior to finish cleanly first.
Task.Factory.StartNew(() =>
{
LogService.Log(LogType, LogMessageType.Debug, GetType().Name, "Waiting for local dispatcher '" + Name + "' to be empty.");
_dispatcher.WaitUntilDone();
LogService.Log(LogType, LogMessageType.Debug, GetType().Name, "'" + Name + "' is disposing.");
// We are now completely done with the dispatcher.
_dispatcher.Dispose();
_dispatcher = null;
});
}
try
{
_finishedEvent.Dispose();
}
catch (ObjectDisposedException)
{
// reset event was disposed
}
//Dispose the UML nodes
DisposeNodes(InitialNode);
if (FinalNode != null)
{
// THIS MAY BE A PROBLEM if SimpleDispatcher is made to dispose IExecutables after executing them.
FinalNode.Dispose();
}
Dispose();
}
private void CreateLocalDispatcher()
{
_dispatcher = new SimpleDispatcher(string.IsNullOrEmpty(ThreadName) ? Name : ThreadName);
_hasLocalDispatcher = true;
}
internal TransportOperationMachine(string name, SimpleDispatcher dispatcher) : base(name, dispatcher)
{
RequiresResourceLocking = true;
IsSynchronous = false;
}
