private void Effects_OnNormalEvent(TEventEntry aevent, TByteBuffer apayload)
{
Execute.OnUIThread(() =>
{
int command = -1;
string strJson = "";
apayload.Read(out command);
apayload.Read(out strJson);
// Debug.WriteLine("NormalEvent received from IMB: [id:{0}, command:{1}]:\n{2}", aevent.ID, command, strJson);
Debug.WriteLine("NormalEvent received from IMB: [id:{0}, command:{1}]:\n{2} bytes", this.GetHashCode(), command, strJson.Length);
if (!string.IsNullOrWhiteSpace(strJson))
{
//todo: fixed in new effects binary, this replace WILL produce problems and MUST be removed:
strJson = strJson.Replace("NAN", "NaN");
var body = JObject.Parse(strJson);
Guid id;
switch (command)
{
case 1102:
Debug.WriteLine("ImbEvent hash: {0}", this.GetHashCode());
SetModelData(body["Models"] as JArray);
break;
case 1104:
var reply = body["ParametersReply"];
id = (Guid)reply["ID"];
SetModelPropertyData(id, reply["Parameters"] as JArray);
break;
case 1106:
var result = body["Result"];
id = (Guid)result["ID"];
SetCalculatedData(id, result["Parameters"] as JArray);
break;
case 1108:
//SetUnitsData
break;
case 1110:
SetChemicalsData(body["ChemicalNames"] as JArray);
break;
}
}
});
}
private void HandleTimerCmd(TEventKind aEventKind, TByteBuffer aPayload) {
if (OnTimerCmd == null) return;
string TimerName;
aPayload.Read(out TimerName);
OnTimerCmd(this, aEventKind, TimerName);
}
private void HandleStreamEvent(TEventKind aEventKind, TByteBuffer aPayload) {
Int32 streamID;
string streamName;
Stream stream;
switch (aEventKind) {
case TEventKind.ekStreamHeader:
if (OnStreamCreate != null) {
aPayload.Read(out streamID);
aPayload.Read(out streamName);
stream = OnStreamCreate(this, streamName);
if (stream != null)
FStreamCache.Cache(streamID, stream, streamName);
}
break;
case TEventKind.ekStreamBody:
aPayload.Read(out streamID);
stream = FStreamCache.Find(streamID, out streamName);
if (stream != null)
stream.Write(aPayload.Buffer, aPayload.ReadCursor, aPayload.ReadAvailable);
break;
case TEventKind.ekStreamTail:
aPayload.Read(out streamID);
stream = FStreamCache.Find(streamID, out streamName);
if (stream != null) {
stream.Write(aPayload.Buffer, aPayload.ReadCursor, aPayload.ReadAvailable);
if (OnStreamEnd != null)
OnStreamEnd(this, ref stream, streamName);
stream.Close();
FStreamCache.Remove(streamID);
}
break;
}
}
private void HandleChangeObjectData(TByteBuffer aPayload) {
if (OnChangeObjectData == null) return;
Int32 action;
Int32 objectID;
string attribute;
aPayload.Read(out action);
aPayload.Read(out objectID);
aPayload.Read(out attribute);
var newValues = aPayload.ReadByteBuffer();
var oldValues = aPayload.ReadByteBuffer();
OnChangeObjectData(this, action, objectID, attribute, newValues, oldValues);
}
private void HandleTimerTick(TByteBuffer aPayload) {
if (OnTimerTick == null) return;
string timerName;
Int32 tick;
Int64 tickTime;
Int64 startTime;
aPayload.Read(out timerName);
aPayload.Read(out tick);
aPayload.Read(out tickTime);
aPayload.Read(out startTime);
OnTimerTick(this, timerName, tick, tickTime, startTime);
}
// dispatchers for specific events
private void HandleChangeObject(TByteBuffer aPayload) {
if (OnFocus != null) {
double x;
double y;
aPayload.Read(out x);
aPayload.Read(out y);
OnFocus(x, y);
}
else {
if (OnChangeFederation != null) {
Int32 Action;
Int32 NewFederationID;
string NewFederation;
aPayload.Read(out Action);
aPayload.Read(out NewFederationID);
aPayload.Read(out NewFederation);
OnChangeFederation(connection, NewFederationID, NewFederation);
}
else {
if (OnChangeObject == null) return;
Int32 Action;
Int32 ObjectID;
string Attribute;
aPayload.Read(out Action);
aPayload.Read(out ObjectID);
aPayload.Read(out Attribute);
OnChangeObject(Action, ObjectID, EventName, Attribute);
}
}
}
// dispatcher for all events
internal void HandleEvent(TByteBuffer aPayload) {
Int32 EventTick;
Int32 EventKindInt;
aPayload.Read(out EventTick);
aPayload.Read(out EventKindInt);
var eventKind = (TEventKind) (EventKindInt & EventKindMask);
switch (eventKind) {
case TEventKind.ekChangeObjectEvent:
HandleChangeObject(aPayload);
break;
case TEventKind.ekChangeObjectDataEvent:
HandleChangeObjectData(aPayload);
break;
case TEventKind.ekBuffer:
HandleBuffer(EventTick, aPayload);
break;
case TEventKind.ekNormalEvent:
if (OnNormalEvent != null)
OnNormalEvent(this, aPayload);
break;
case TEventKind.ekTimerTick:
HandleTimerTick(aPayload);
break;
case TEventKind.ekTimerPrepare:
case TEventKind.ekTimerStart:
case TEventKind.ekTimerStop:
HandleTimerCmd(eventKind, aPayload);
break;
case TEventKind.ekStreamHeader:
case TEventKind.ekStreamBody:
case TEventKind.ekStreamTail:
HandleStreamEvent(eventKind, aPayload);
break;
default:
if (OnOtherEvent != null)
OnOtherEvent(this, EventTick, eventKind, aPayload);
break;
}
}
private void HandleSubAndPub(TCommands aCommand, TByteBuffer aPayload) {
string eventName;
TEventEntry ee;
switch (aCommand) {
case TCommands.icSubscribe:
case TCommands.icPublish:
Int32 eventID;
aPayload.Read(out eventID);
Int32 eventEntryType;
aPayload.Read(out eventEntryType);
aPayload.Read(out eventName);
ee = FindEventL(eventName);
if (ee == null) {
var ep = FindEventParentL(eventName);
if (ep != null) {
ee = AddEventL(eventName);
ee.FParent = ep;
ee.CopyHandlersFrom(ep);
}
}
else {
if (OnSubAndPub != null && !ee.IsEmpty)
OnSubAndPub(this, aCommand, eventName);
}
if (ee != null)
ee.HandleOnSubAndPub(aCommand);
break;
case TCommands.icUnsubscribe:
case TCommands.icUnpublish:
aPayload.Read(out eventName);
if (OnSubAndPub != null)
OnSubAndPub(this, aCommand, eventName);
ee = FindEventL(eventName);
if (ee != null)
ee.HandleOnSubAndPub(aCommand);
break;
}
}
private void HandleEventNames(TByteBuffer aPayload) {
if (OnEventNames == null) return;
Int32 ec;
aPayload.Read(out ec);
var eventNames = new TEventNameEntry[ec];
for (var en = 0; en < eventNames.Length; en++) {
eventNames[en] = new TEventNameEntry {
EventName = aPayload.ReadString(),
Publishers = aPayload.ReadInt32(),
Subscribers = aPayload.ReadInt32(),
Timers = aPayload.ReadInt32()
};
}
OnEventNames(this, eventNames);
}
// command handlers
protected override void HandleCommand(TCommands aCommand, TByteBuffer aPayload) {
switch (aCommand) {
case TCommands.icEvent:
HandleCommandEvent(aPayload);
break;
case TCommands.icSetVariable:
HandleCommandVariable(aPayload);
break;
case TCommands.icSetEventIDTranslation:
FEventTranslation.SetEventTranslation(
aPayload.PeekInt32(0, TEventTranslation.InvalidTranslatedEventID),
aPayload.PeekInt32(sizeof (Int32), TEventTranslation.InvalidTranslatedEventID));
break;
case TCommands.icUniqueClientID:
aPayload.Read(out FUniqueClientID);
aPayload.Read(out FClientHandle);
break;
case TCommands.icTimeStamp:
// ignore for now, only when using and syncing local time (we trust hub time for now)
aPayload.Read(out FBrokerAbsoluteTime);
aPayload.Read(out FBrokerTick);
aPayload.Read(out FBrokerTickDelta);
break;
case TCommands.icEventNames:
HandleEventNames(aPayload);
break;
case TCommands.icEndSession:
Close();
break;
case TCommands.icSubscribe:
case TCommands.icPublish:
case TCommands.icUnsubscribe:
case TCommands.icUnpublish:
HandleSubAndPub(aCommand, aPayload);
break;
default:
HandleCommandOther(aCommand, aPayload);
break;
}
}
