public override int HandleEvent(string sSender, int iChannelId, int iEventId, string sEvent)
{
var guid = Guid.NewGuid().ToString();
GlobalDefinition.LoggerWrapper.LogDevInfo("####################Receive Event.#######################" + guid +
"########eventId:" + iEventId);
if (String.IsNullOrEmpty(sSender))
{
GlobalDefinition.LoggerWrapper.LogDevInfo(
"####################processed Event.#######################" + guid + "########eventId:" + iEventId);
GlobalDefinition.LoggerWrapper.LogDevWarning("PRFE Event sender is empty ....");
return(0);
}
if (null == EventMap || !EventMap.ContainsKey(iEventId))
{
GlobalDefinition.LoggerWrapper.LogDevInfo(
"####################processed Event.#######################" + guid + "########eventId:" + iEventId);
GlobalDefinition.LoggerWrapper.LogDevWarning("EventMap is null or not contains this event id");
return(0);
}
if (null == EventMap[iEventId])
{
GlobalDefinition.LoggerWrapper.LogDevInfo(
"####################processed Event.#######################" + guid + "########eventId:" + iEventId);
GlobalDefinition.LoggerWrapper.LogDevWarning("There's no event handler of this event id");
return(0);
}
try
{
EventMap[iEventId](sEvent);
}
catch (Exception ex)
{
GlobalDefinition.LoggerWrapper.LogDevInfo(
"####################processed Event exception.#######################" + guid + "########eventId:" +
iEventId);
GlobalDefinition.LoggerWrapper.LogDevError(ex.Message);
GlobalDefinition.LoggerWrapper.LogDevError(ex.StackTrace);
return(0);
}
GlobalDefinition.LoggerWrapper.LogDevInfo("####################processed Event.#######################" +
guid + "########eventId:" + iEventId);
return(0);
}
private DiagnosticAnalyzerService(IDiagnosticUpdateSourceRegistrationService registrationService) : this()
{
_eventMap = new EventMap();
_eventQueue = new SimpleTaskQueue(TaskScheduler.Default);
registrationService.Register(this);
}
private DiagnosticAnalyzerService(IDiagnosticUpdateSourceRegistrationService registrationService) : this()
{
_eventMap = new EventMap();
_eventQueue = new SimpleTaskQueue(TaskScheduler.Default);
registrationService.Register(this);
}
private void RunButtonClick(string name)
{
if (EventMap.ContainsKey(name))
{
EventMap[name].Invoke();
}
}
private async Task RecoveryProcessing(ISession session, EventModel data, Vwcontractorsite siteInfo, IEnumerable <UInt32> bitflags)
{
IList <EventMap> map = await GetEventMaps(session, data, bitflags);
if (map == null || map.Count == 0) // 없는 이벤트 일 경우 무시
{
return;
}
var existEvents = await session.CreateCriteria <EventRecord>().Add(
Restrictions.InG <int>("Eventcode", map.Select(x => x.Eventcode)) && Restrictions.IsNull("Recoveryts") &&
Restrictions.Eq("Devicetype", data.DeviceType) &&
Restrictions.Eq("Deviceindex", data.DeviceIndex) &&
Restrictions.Eq("Siteid", data.SiteId)).ListAsync <EventRecord>();
foreach (EventRecord record in existEvents)
{
DateTime dt = DateTime.FromFileTime(data.UnixTimestamp);
record.Recoveryts = dt;
await session.UpdateAsync(record);
EventMap target_map = map.FirstOrDefault(x => x.Eventcode == record.Eventcode);
await RecoveryReportMMS(siteInfo.Represenation, data.SiteId, data.DeviceType, data.DeviceIndex, target_map.Name, dt);
logger.LogWarning($"[RECOVERY EVENT] SITEID: {data.SiteId} / GC:{data.GroupCode} / BF:tail{data.BitFlag} / DT:{data.DeviceType} / INDEX:{data.DeviceIndex}");
}
}
private async Task FaultProcessing(ISession session, EventModel data, Vwcontractorsite siteInfo, IEnumerable <UInt32> bitflags)
{
foreach (UInt32 bit in bitflags)
{
// 발생한 이벤트가 이미 존재하는지 체크
EventMap map = await GetEventMap(session, data, bit);
// 복구 이벤트 체크
if (map == null)
{
continue;
}
var existEvents = await session.CreateCriteria <EventRecord>().Add(
Restrictions.Eq("Eventcode", map.Eventcode) && Restrictions.IsNull("Recoveryts") &&
Restrictions.Eq("Devicetype", data.DeviceType) &&
Restrictions.Eq("Deviceindex", data.DeviceIndex) &&
Restrictions.Eq("Siteid", data.SiteId)).ListAsync <EventRecord>();
// 이벤트가 발생했는데, 기존에 엑티브 이벤트에 없을 경우 이벤트를 인서트 한다.
if (existEvents.Count == 0)
{
EventRecord newEventRecode = new EventRecord();
DateTime dt = DateTime.FromFileTime(data.UnixTimestamp);
newEventRecode.Createts = dt;
newEventRecode.Eventcode = map.Eventcode;
newEventRecode.Siteid = data.SiteId;
newEventRecode.Devicetype = data.DeviceType;
newEventRecode.Deviceindex = data.DeviceIndex;
await session.SaveOrUpdateAsync(newEventRecode);
await FaultReportMMS(siteInfo.Represenation, data.SiteId, data.DeviceType, data.DeviceIndex, map.Name, dt);
logger.LogWarning($"[NEW EVENT] SITEID: {data.SiteId} / GC:{data.GroupCode} / BF:{bit} / DT:{data.DeviceType} / INDEX:{data.DeviceIndex}");
}
}
}
private void InitEventMap()
{
float avgLatitude = 0, avgLongitude = 0;
foreach (var activity in _event.Activities)
{
var pin = new Pin();
var place = activity.Place;
pin.Position = new Position(place.Latitude, place.Longitude);
pin.Label = place.Name;
avgLatitude += place.Latitude;
avgLongitude += place.Longitude;
EventMap.Pins.Add(pin);
}
if (_event.Activities.Count != 0)
{
avgLatitude /= _event.Activities.Count;
avgLongitude /= _event.Activities.Count;
EventMap.MoveToRegion(
MapSpan.FromCenterAndRadius(
new Position(avgLatitude, avgLongitude), Distance.FromMeters(400)));
}
else
{
EventMap.MoveToRegion(
MapSpan.FromCenterAndRadius(
new Position(53.118293, 23.149717), Distance.FromMeters(300)));
}
}
protected override void OnDisposing(bool manually)
{
if (music != null)
{
music.FadeOut(1f);
music = null;
}
foreach (Player player in players)
{
player.AttachToHud(null);
}
if (eventMap != null)
{
eventMap.Dispose();
eventMap = null;
}
if (tileMap != null)
{
tileMap.ReleaseResources();
tileMap = null;
}
api = null;
base.OnDisposing(manually);
}
public FireDBRefence(MonoBehaviour c, DatabaseReference body)
{
context = c;
this.body = body;
valueEventMap = new EventMap <ValueChangedEventArgs>(body, t => {
return(t.Snapshot);
}, h => {
this.body.ValueChanged += h;
}, h => {
this.body.ValueChanged -= h;
});
addEventMap = new EventMap <ChildChangedEventArgs>(body, t => {
return(t.Snapshot);
}, h => {
this.body.ChildAdded += h;
}, h => {
this.body.ChildAdded -= h;
});
removeEventMap = new EventMap <ChildChangedEventArgs>(body, t => {
return(t.Snapshot);
}, h => {
this.body.ChildRemoved += h;
}, h => {
this.body.ChildRemoved -= h;
});
}
public void PostConstruct()
{
EventMap.Map(AppEvent.Pause, OnAppPause);
CheckOrientation();
StartOrientationCheck();
}
public DiagnosticService(
IAsynchronousOperationListenerProvider listenerProvider,
[ImportMany] IEnumerable <Lazy <IEventListener, EventListenerMetadata> > eventListeners
)
{
// we use registry service rather than doing MEF import since MEF import method can have race issue where
// update source gets created before aggregator - diagnostic service - is created and we will lose events fired before
// the aggregator is created.
_updateSources = ImmutableHashSet <IDiagnosticUpdateSource> .Empty;
// queue to serialize events.
_eventMap = new EventMap();
_eventQueue = new TaskQueue(
listenerProvider.GetListener(FeatureAttribute.DiagnosticService),
TaskScheduler.Default
);
_gate = new object();
_map =
new Dictionary <
IDiagnosticUpdateSource,
Dictionary <Workspace, Dictionary <object, Data> >
>();
_eventListenerTracker = new EventListenerTracker <IDiagnosticService>(
eventListeners,
WellKnownEventListeners.DiagnosticService
);
}
private static void AddPropertyAssertHandlersToRegistry(Recorder recorder, EventMap events)
{
if (Types.HasPublicProperties(recorder.TesterType))
{
Delegate handler = Delegate.CreateDelegate(typeof(EventHandler), recorder, PropertyAssert, false);
events.Add(PropertyAssert, handler);
}
}
public SolutionCrawlerProgressReporter(IAsynchronousOperationListener listener)
{
_listener = listener;
_eventQueue = new SimpleTaskQueue(TaskScheduler.Default);
_eventMap = new EventMap();
_count = 0;
}
public SolutionCrawlerProgressReporter(IAsynchronousOperationListener listener)
{
_listener = listener;
_eventQueue = new SimpleTaskQueue(TaskScheduler.Default);
_eventMap = new EventMap();
_count = 0;
}
protected override async Task OnMessageReceivedAsync(MqttApplicationMessageReceivedEventArgs e)
{
byte[] packet = e.ApplicationMessage.Payload;
string txt = Encoding.UTF8.GetString(packet);
try
{
EventModel data = JsonConvert.DeserializeObject <EventModel>(txt);
using (var session = sessionFactory.OpenStatelessSession())
using (var transaction = session.BeginTransaction())
{
EventMap map = session.Get <EventMap>(data.EventCode);
string redisKey = $"SID{data.SiteId}.EVENT.{data.DeviceId}";
Program.logger.Info($"Received Event: {data.EventCode} / Status: {data.Status}");
switch (data.Status)
{
case EventStatus.New:
await redisDb.HashSetAsync(redisKey, $"{data.EventCode}", bool.TrueString);
// 새로 발생한 이벤트
IList <EventRecord> ev = await FindNewRaiseEvent(data.EventCode, session.CreateCriteria <EventRecord>());
if (ev.Count > 0)
{
return;
}
EventRecord newEventRecode = new EventRecord();
newEventRecode.CreateDT = new DateTime(1970, 1, 1).AddSeconds(data.UnixTimestamp).ToLocalTime();
newEventRecode.EventId = data.EventCode;
newEventRecode.SiteId = data.SiteId;
newEventRecode.DeviceId = data.DeviceId;
await session.InsertAsync(newEventRecode);
break;
case EventStatus.Recovery:
await redisDb.HashSetAsync(redisKey, $"{data.EventCode}", bool.FalseString);
var rc_result = await FindNewRaiseEvent(data.EventCode, session.CreateCriteria <EventRecord>());
if (rc_result.Count > 0)
{
foreach (EventRecord exist_record in rc_result)
{
exist_record.RecoveryDT = new DateTime(1970, 1, 1).AddSeconds(data.UnixTimestamp).ToLocalTime();
await session.UpdateAsync(exist_record);
}
}
break;
}
await transaction.CommitAsync();
}
}
catch (Exception ex)
{
Program.logger.Error(ex, ex.Message);
}
}
public static EventMap Instance()
{
if (instance == null)
{
instance = new EventMap();
}
return(instance);
}
void Instantiate()
{
//DontDestroyOnLoad(gameObject);
recognizer = new GestureRecognizer();
recognizer.SetRecognizableGestures(GestureSettings.Tap);
recognizer.TappedEvent += OnTap;
eventMap = new EventMap();
GrantControl();
}
private void Awake()
{
m_onKeyEventMap = new EventMap <KeyCode> ();
m_onKeyUpEventMap = new EventMap <KeyCode> ();
m_onKeyDownEventMap = new EventMap <KeyCode> ();
m_onMouseButtonEventMap = new EventMap <int> ();
m_onMouseButtonUpEventMap = new EventMap <int> ();
m_onMouseButtonDownEventMap = new EventMap <int> ();
}
static bool IsOverriden(EventMap emap, Type thisType, Type t)
{
var method = thisType.GetMethod(emap.MethodName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
if (method == null)
{
throw new InvalidOperationException("Invalid event mapping: method '" + emap.MethodName + "' not found in type '" + t + "'");
}
return(method.DeclaringType != t);
}
private DiagnosticAnalyzerService(IDiagnosticUpdateSourceRegistrationService registrationService) : this()
{
_eventMap = new EventMap();
// use diagnostic event task scheduler so that we never flood async events queue with million of events.
// queue itself can handle huge number of events but we are seeing OOM due to captured data in pending events.
_eventQueue = new SimpleTaskQueue(s_eventScheduler);
registrationService.Register(this);
}
private DiagnosticAnalyzerService(IDiagnosticUpdateSourceRegistrationService registrationService) : this()
{
_eventMap = new EventMap();
// use diagnostic event task scheduler so that we never flood async events queue with million of events.
// queue itself can handle huge number of events but we are seeing OOM due to captured data in pending events.
_eventQueue = new SimpleTaskQueue(s_eventScheduler);
registrationService.Register(this);
}
private void AddRecorderToRegistry(Type type, Listener listener)
{
Recorder recorder = (Recorder)Activator.CreateInstance(type, new object[] { listener });
EventMap events = new EventMap();
AddEventHandlersToRegistry(recorder, type, events);
AddPropertyAssertHandlersToRegistry(recorder, events);
eventTable.Add(recorder.RecorderType, events);
}
public void ProcessEvent(string eventName)
{
if (EventMap.ContainsKey(eventName))
{
List <CCFunction> cceventList = EventMap[eventName];
foreach (CCFunction function in cceventList)
{
ProcessFunction(function);
}
}
}
public EventsMapViewModel(IMobEventManager mobEventManager)
{
Title = "Events Map";
this.mobEventManager = mobEventManager;
Map = new EventMap()
{
MapType = MapType.Street
};
Task.Run(async() => await LoadEvents());
}
// Start is called before the first frame update
void Start()
{
Transform canvas = FindObjectOfType <Canvas>().transform;
fuelSlider = Instantiate(fuelSlider, canvas);
meteorSlider = Instantiate(meteorSlider, canvas);
EMPSlider = Instantiate(EMPSlider, canvas);
progressSlider = Instantiate(progressSlider, canvas);
events = FindObjectOfType <EventMap>();
progressSlider = Instantiate(progressSlider, canvas);
}
public DiagnosticService([ImportMany] IEnumerable <Lazy <IAsynchronousOperationListener, FeatureMetadata> > asyncListeners) : this()
{
// queue to serialize events.
_eventMap = new EventMap();
_eventQueue = new SimpleTaskQueue(TaskScheduler.Default);
_listener = new AggregateAsynchronousOperationListener(asyncListeners, FeatureAttribute.DiagnosticService);
_gate = new object();
_map = new Dictionary <IDiagnosticUpdateSource, Dictionary <object, Data> >();
}
private async void LoadMap(DojoLocation location)
{
Geopoint eventLocation = GenerateGeoPoint(location);
MapIcon myPOI = new MapIcon {
Location = eventLocation,
NormalizedAnchorPoint = new Point(0.5, 1.0),
Title = "Coder Dojo!", ZIndex = 0
};
EventMap.MapElements.Add(myPOI);
await EventMap.TrySetSceneAsync(MapScene.CreateFromLocationAndRadius(eventLocation, 150));
}
protected void CheckCollisions(float timeMult)
{
if (health <= 0)
{
return;
}
TileMap tiles = levelHandler.TileMap;
if (tiles != null)
{
AABB adjustedAABB = AABBInner + new Vector2(speedX * timeMult, speedY * timeMult);
if (tiles.CheckWeaponDestructible(ref adjustedAABB, WeaponType, strength) > 0)
{
if (WeaponType != WeaponType.Freezer)
{
if (owner != null)
{
owner.AddScore(50);
}
}
DecreaseHealth(1);
}
else if (!tiles.IsTileEmpty(ref AABBInner, false))
{
EventMap events = levelHandler.EventMap;
bool handled = false;
if (events != null)
{
Vector3 pos = Transform.Pos;
ushort[] eventParams = null;
switch (events.GetEventByPosition(pos.X + speedX * timeMult, pos.Y + speedY * timeMult, ref eventParams))
{
case EventType.ModifierRicochet:
if (lastRicochetFrame + 2 < Time.FrameCount)
{
lastRicochet = null;
lastRicochetFrame = Time.FrameCount;
OnRicochet();
handled = true;
}
break;
}
}
if (!handled)
{
OnHitWall();
}
}
}
}
/// <summary>
/// Maps an event handler of an Xwt component to an event identifier.
/// </summary>
/// <param name="eventId">The event identifier (must be valid event enum value
/// like <see cref="Xwt.Backends.WidgetEvent"/>, identifying component specific events).</param>
/// <param name="type">The Xwt component type.</param>
/// <param name="methodName">The <see cref="System.Reflection.MethodInfo.Name"/> of the event handler.</param>
private static void MapEvent (object eventId, Type type, string methodName)
{
List<EventMap> events;
if (!overridenEventMap.TryGetValue (type, out events)) {
events = new List<EventMap> ();
overridenEventMap [type] = events;
}
EventMap emap = new EventMap () {
MethodName = methodName,
EventId = eventId
};
events.Add (emap);
}
internal void WriteEventMap(EventMap eventMap)
{
if (eventMap.UpdateRowOnRebuild)
{
object[] parts = new object[]
{
GetMemberIndex(eventMap.Parent),
GetMemberIndex(eventMap.Events[0]),
};
eventMap.MetaDataRow = new MetaDataRow(parts);
}
writer.Write(eventMap.MetaDataRow.GenerateBytes());
}
public DiagnosticService([ImportMany] IEnumerable <Lazy <IAsynchronousOperationListener, FeatureMetadata> > asyncListeners) : this()
{
// queue to serialize events.
_eventMap = new EventMap();
// use diagnostic event task scheduler so that we never flood async events queue with million of events.
// queue itself can handle huge number of events but we are seeing OOM due to captured data in pending events.
_eventQueue = new SimpleTaskQueue(s_eventScheduler);
_listener = new AggregateAsynchronousOperationListener(asyncListeners, FeatureAttribute.DiagnosticService);
_gate = new object();
_map = new Dictionary <IDiagnosticUpdateSource, Dictionary <object, Data> >();
}
public EventMapEntry(PEFile module, byte *ptr, int metadataOffset, int row)
{
this.module = module;
this.metadata = module.Metadata;
this.RID = row;
var rowOffset = metadata.GetTableMetadataOffset(TableIndex.EventMap)
+ metadata.GetTableRowSize(TableIndex.EventMap) * (row - 1);
this.Offset = metadataOffset + rowOffset;
int typeDefSize = metadata.GetTableRowCount(TableIndex.TypeDef) < ushort.MaxValue ? 2 : 4;
int eventDefSize = metadata.GetTableRowCount(TableIndex.Event) < ushort.MaxValue ? 2 : 4;
this.eventMap = new EventMap(ptr + rowOffset, typeDefSize, eventDefSize);
}
public DiagnosticService(
IAsynchronousOperationListenerProvider listenerProvider,
[ImportMany] IEnumerable <Lazy <IEventListener, EventListenerMetadata> > eventListeners) : this()
{
// queue to serialize events.
_eventMap = new EventMap();
_eventQueue = new TaskQueue(listenerProvider.GetListener(FeatureAttribute.DiagnosticService), TaskScheduler.Default);
_gate = new object();
_map = new Dictionary <IDiagnosticUpdateSource, Dictionary <Workspace, Dictionary <object, Data> > >();
_eventListenerTracker = new EventListenerTracker <IDiagnosticService>(eventListeners, WellKnownEventListeners.DiagnosticService);
}
protected virtual bool OnPerish(ActorBase collider)
{
EventMap events = api.EventMap;
if (events != null && (flags & ActorInstantiationFlags.IsCreatedFromEventMap) != 0)
{
events.Deactivate(originTile.X, originTile.Y);
events.StoreTileEvent(originTile.X, originTile.Y, EventType.Empty);
}
api.RemoveActor(this);
return(true);
}
internal PXCMTouchlessController(EventMap maps, IntPtr instance, Boolean delete)
: base(instance, delete)
{
this.maps = maps;
}
internal PXCMTouchlessController(IntPtr instance, Boolean delete)
: base(instance, delete)
{
maps = new EventMap();
}
static bool IsOverriden (EventMap emap, Type thisType, Type t)
{
var method = thisType.GetMethod (emap.MethodName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
if (method == null)
throw new InvalidOperationException ("Invalid event mapping: method '" + emap.MethodName + "' not found in type '" + t + "'");
return method.DeclaringType != t;
}
static bool IsOverriden (EventMap emap, Type thisType, Type t)
{
var method = thisType.GetMethod (emap.MethodName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
return method.DeclaringType != t;
}
