private void TriggerEventInternal(IEvent triggeredEvent)
{
if (LoggingEnabled)
{
Log.Debug($"[EventService] Triggered event for {triggeredEvent.Name} with lifespan of {triggeredEvent.Lifespan}");
}
if (triggeredEvent.Lifespan != EventLifespan.Instant)
{
if (Events.ContainsKey(triggeredEvent.Name))
{
Events[triggeredEvent.Name].Add(triggeredEvent);
}
else
{
Events.Add(triggeredEvent.Name, new EventsList()
{
triggeredEvent
});
}
}
TSDevsUnityEvent unityEvent = null;
if (Listeners.TryGetValue(triggeredEvent.Name, out unityEvent))
{
if (!triggeredEvent.IsHandled)
{
unityEvent.Invoke(triggeredEvent);
}
}
}
public bool Register(string connectionId, Action <string[]> onChanged)
{
ConcurrentDictionary <string, IDisposable> dict;
if (!Listeners.TryGetValue(typeof(TDomainObject), out dict))
{
dict = new ConcurrentDictionary <string, IDisposable>();
if (!Listeners.TryAdd(typeof(TDomainObject), dict))
{
return(false);
}
}
var name = typeof(TDomainObject).FullName;
var listener = ChangeNotification.Track <TDomainObject>().Subscribe(kv => onChanged(kv.Key));
if (!dict.TryAdd(connectionId, listener))
{
listener.Dispose();
}
else
{
ConcurrentBag <Type> bag;
if (!Connections.TryGetValue(connectionId, out bag))
{
bag = new ConcurrentBag <Type>();
Connections.TryAdd(connectionId, bag);
}
bag.Add(typeof(TDomainObject));
}
return(true);
}
private void RemoveListenerInternal(string name, EventAction action)
{
TSDevsUnityEvent unityEvent = null;
if (Listeners.TryGetValue(name, out unityEvent))
{
unityEvent.RemoveListener(action);
}
}
} // TODO: Re-evaluate need for static instance counter - it was added for testing IoC only
public void PublishEvent(IEvent evnt)
{
List <IEventListener> listeners;
if (Listeners.TryGetValue(evnt.GetType(), out listeners))
{
listeners.ForEach(a => a.HandleEvent(evnt));
}
}
public override void RemoveListener(string key)
{
IMyTraceListener listener;
if (!Listeners.TryGetValue(key, out listener))
{
return;
}
base.RemoveListener(key);
}
private void RemoveListenerAndReplaceWithSameType(string key)
{
string str = GetFileNameFromActiveListener(key);
RemoveListener(key);
IMyTraceListener listener;
if (Listeners.TryGetValue(key, out listener))
{
listener.WriteCommentAndNewLine("logging continued from " + str);
}
}
private void AddListenerInternal(string name, EventAction action)
{
TSDevsUnityEvent unityEvent = null;
if (Listeners.TryGetValue(name, out unityEvent))
{
unityEvent.AddListener(action);
}
else
{
unityEvent = new TSDevsUnityEvent();
unityEvent.AddListener(action);
Listeners.Add(name, unityEvent);
}
}
public bool Register(string connectionId, Type type, string specificationJson, Action <string> onMatched)
{
Func <TDomainObject, bool> isMatched;
try
{
ISpecification <TDomainObject> specification = (ISpecification <TDomainObject>)Newtonsoft.Json.JsonConvert.DeserializeObject(specificationJson, type);
isMatched = specification.IsSatisfied.Compile();
}
catch { return(false); }
ConcurrentDictionary <string, IDisposable> dict;
if (!Listeners.TryGetValue(typeof(TDomainObject), out dict))
{
dict = new ConcurrentDictionary <string, IDisposable>();
if (!Listeners.TryAdd(typeof(TDomainObject), dict))
{
return(false);
}
}
var name = typeof(TDomainObject).FullName;
var listener = ChangeNotification.Track <TDomainObject>().Subscribe(kv =>
{
foreach (var v in kv.Value.Value)
{
if (isMatched(v))
{
onMatched(v.URI);
}
}
});
if (!dict.TryAdd(connectionId, listener))
{
listener.Dispose();
}
else
{
ConcurrentBag <Type> bag;
if (!Connections.TryGetValue(connectionId, out bag))
{
bag = new ConcurrentBag <Type>();
Connections.TryAdd(connectionId, bag);
}
bag.Add(typeof(TDomainObject));
}
return(true);
}
public override void RemoveListener(string key)
{
IMyTraceListener listener;
if (!Listeners.TryGetValue(key, out listener))
{
return;
}
if (listener.Uploadable)
{
((TraceListenerUploadableBase)listener).Upload -= TraceUploadEventHandler;
}
base.RemoveListener(key);
}
private void AddListener(IEventListener listener, Type eventType)
{
var dlist = new List <IEventListener>();
if (Listeners.TryGetValue(eventType, out dlist))
{
if (!dlist.Contains(listener))
{
dlist.Add(listener);
}
}
else
{
dlist = new List <IEventListener> {
listener
};
Listeners.TryAdd(eventType, dlist);
}
}
/// <summary>
/// Removes the listener from the specified priority level.
/// </summary>
/// <param name="priority">Priority that the listener was registered under.</param>
/// <param name="callback">Function that was registered as a listener.</param>
public static void RemoveListener(int priority, EventCallback callback)
{
if (callback == null)
{
throw new ArgumentException(nameof(callback), $"Trying to remove a callback with null value from event type '{GenericTypeName}'.");
}
// Check there is a list of listeners for this priority
if (Listeners.TryGetValue(priority, out List <EventCallback> listeners))
{
listeners.Remove(callback);
// Remove this priority if there are no more listeners
if (listeners == null || listeners.Count == 0)
{
Listeners.RemoveAt(priority);
}
}
}
/// <summary>
/// Adds a listener for this event type.
/// </summary>
/// <param name="priority">Priority of the listener. A lower value means the callback will be called earlier.</param>
/// <param name="callback">Function to call when the event is fired.</param>
public static void RegisterListener(int priority, EventCallback callback)
{
if (callback == null)
{
throw new ArgumentException(nameof(callback), $"Callback for event '{GenericTypeName}' cannot be null.");
}
// Check there is a list of listeners for this priority. If there isn't create one
if (Listeners.TryGetValue(priority, out List <EventCallback> listeners))
{
listeners.Add(callback);
}
else
{
Listeners.Add(priority, new List <EventCallback> {
callback
});
}
}
private async void ReceiveAsync(CancellationToken token)
{
var buffer = new byte[1024 * 4];
var done = false;
while (!done)
{
WebSocketReceiveResult result = null;
try
{
result = await Socket.ReceiveAsync(new ArraySegment <byte>(buffer), token).ConfigureAwait(false);
}
catch (WebSocketException)
{
await StopAsync(graceful : false).ConfigureAwait(false);
break;
}
catch (InvalidOperationException)
{
break;
}
catch (TaskCanceledException)
{
break;
}
catch (OperationCanceledException)
{
break;
}
MessageResponse message = null;
// TODO: make serializers more modular
switch (result?.MessageType)
{
case WebSocketMessageType.Text:
var str = Encoding.UTF8.GetString(buffer, 0, result.Count);
message = JsonConvert.DeserializeObject <MessageResponse>(str);
break;
case WebSocketMessageType.Close:
await StopAsync(graceful : false).ConfigureAwait(false);
done = true;
break;
case WebSocketMessageType.Binary:
// TODO implement binary protocols
break;
case null:
// do nothing;
break;
default:
throw new ArgumentOutOfRangeException();
}
if (message == null)
{
continue;
}
MessageReceived?.Invoke(this, new MessageEventArgs {
Message = message
});
if (message.Path != null && Watchers.ContainsKey(message.Path))
{
lock (Watchers[message.Path])
{
var removeThese = new List <int>();
var i = 0;
foreach (var w in Watchers[message.Path])
{
var wKeep = w.Invoke(message);
if (wKeep != true)
{
removeThese.Add(i);
}
i++;
}
removeThese
.Reverse(); // IMPORTANT: make sure you reverse so that the larger numbers get removed first, prevents wrong indexes later on.
foreach (var r in removeThese)
{
Watchers[message.Path].RemoveAt(r);
}
}
}
if (message.Id == null)
{
continue;
}
Listeners.TryGetValue(message.Id, out var listener);
if (listener == null)
{
continue;
}
var l = listener.Value;
var keep = l.Callback(message);
if (keep != true)
{
Listeners.TryRemove(message.Id, out var _);
}
l.TaskCompleter.SetResult(true);
}
}
