public void Register(EMessageTypes messageType, Action callback)
{
if (!_map.ContainsKey(messageType))
{
var list = new List <Action> {
callback
};
_map.Add(messageType, list);
}
else
{
bool found = false;
foreach (var item in _map[messageType])
{
if (item.Method.ToString() == callback.Method.ToString())
{
found = true;
}
}
if (!found)
{
_map[messageType].Add(callback);
}
}
}
public static List <byte[]> ParsePacket(byte[] packet, ref EMessageTypes type, ref int seqID, ref string func)
{
try
{
using (MemoryStream dataStream = new MemoryStream(packet))
{
var dataReader = new BinaryReader(dataStream);
type = (EMessageTypes)dataReader.ReadByte();
seqID = dataReader.ReadInt32();
func = dataReader.ReadString();
List <byte[]> args = new List <byte[]>();
int count = dataReader.ReadInt32();
for (int i = 0; i < count; i++)
{
int length = dataReader.ReadInt32();
args.Add(dataReader.ReadBytes(length));
}
return(args);
}
}
catch
{
return(null);
}
}
public void UnRegister(EMessageTypes messageType, Action callback)
{
if (_map.ContainsKey(messageType))
{
_map[messageType].Remove(callback);
}
}
public void AddListener()
{
PipeListener serverPipe = new PipeListener(Name);
serverPipes.Add(serverPipe);
serverPipe.DataReceived += (sndr, data) =>
{
//mDispatcher.BeginInvoke(new Action(() => {
EMessageTypes type = EMessageTypes.eCall;
int seqID = 0;
string func = null;
List <byte[]> args = PipeListener.ParsePacket(data, ref type, ref seqID, ref func);
List <byte[]> ret = null;
if (func == "InitSession")
{
int SessionId = BitConverter.ToInt32(args[0], 0);
bool Duplicate = mDispatcher.Invoke(new Func <bool>(() => {
return(CountSessions(SessionId) > 0);
}));
ret = new List <byte[]>();
ret.Add(BitConverter.GetBytes(Duplicate));
serverPipe.SessionID = SessionId;
}
else if (args != null)
{
ret = Process(func, args);
}
if (ret != null)
{
serverPipe.SendPacket(type, seqID, func, ret);
}
//}));
};
serverPipe.Connected += (sndr, args) =>
{
mDispatcher.BeginInvoke(new Action(() => {
// if we used a listener allocate a replacement one
AddListener();
}));
};
serverPipe.PipeClosed += (sndr, args) =>
{
mDispatcher.BeginInvoke(new Action(() => {
serverPipes.Remove(serverPipe);
}));
};
}
public void NotifyColleagues(EMessageTypes messageType, object args)
{
if (_map.ContainsKey(messageType))
{
foreach (var callback in _map[messageType])
{
callback();
}
}
}
public bool Connect(int TimeOut = 10000)
{
try
{
pipeStream.Connect(TimeOut);
}
catch
{
return(false); // timeout
}
DataReceived += (sndr, data) =>
{
EMessageTypes type = EMessageTypes.eCall;
int seqID = 0;
string func = null;
List <byte[]> args = ParsePacket(data, ref type, ref seqID, ref func);
if (type == EMessageTypes.ePush)
{
PushNotification?.Invoke(this, new Tuple <string, List <byte[]> >(func, args));
}
else if (type == EMessageTypes.eCall)
{
if (seqID != seqIDctr)
{
Debug.Write("seqID != seqIDctr");
}
else
{
retObj = new Tuple <string, List <byte[]> >(func, args);
done.Set();
}
}
};
PipeClosed += (sndr, args) =>
{
done.Set();
};
startRecv();
return(true);
}
private static string GetSubUrl(EMessageTypes _MsgType)
{
switch (_MsgType)
{
case EMessageTypes.MSG_LOAD_REFERENTS:
return("referents/list");
case EMessageTypes.MSG_LOAD_ALL_EVENTS:
return("events/list");
case EMessageTypes.MSG_SEND_USER_DATA:
return("users/add");
case EMessageTypes.MSG_CHECK_UNLOCK_KEY:
return("companies/check");
case EMessageTypes.MSG_SEND_RESERVATION:
return("events/reserve");
case EMessageTypes.MSG_LOAD_USER_EVENTS:
return("events/listuserevents");
case EMessageTypes.MSG_LOAD_NOTIFICATIONS:
return("notifications/list");
case EMessageTypes.MSG_SEND_FEEDBACK:
return("feedback/add");
case EMessageTypes.MSG_LOAD_BREAKOUT_SESSION:
return("events/listbreakout");
case EMessageTypes.MSG_LOAD_SINGLE_EVENT:
return("events/single");
case EMessageTypes.MSG_LOAD_STANDS:
return("stands/list");
default:
// WTF??
throw new NotImplementedException();
}
}
private static bool IsGetCall(EMessageTypes _MsgType)
{
switch (_MsgType)
{
case EMessageTypes.MSG_LOAD_REFERENTS:
return(true);
case EMessageTypes.MSG_LOAD_ALL_EVENTS:
return(false);
case EMessageTypes.MSG_SEND_USER_DATA:
return(false);
case EMessageTypes.MSG_CHECK_UNLOCK_KEY:
return(false);
case EMessageTypes.MSG_SEND_RESERVATION:
return(false);
case EMessageTypes.MSG_LOAD_USER_EVENTS:
return(false);
case EMessageTypes.MSG_LOAD_NOTIFICATIONS:
return(false);
case EMessageTypes.MSG_SEND_FEEDBACK:
return(false);
case EMessageTypes.MSG_LOAD_BREAKOUT_SESSION:
return(false);
case EMessageTypes.MSG_LOAD_SINGLE_EVENT:
return(false);
case EMessageTypes.MSG_LOAD_STANDS:
return(true);
default:
// WTF??
throw new NotImplementedException();
}
}
private async static void CallServer(EMessageTypes _MsgType, string _Data, Delegate _OnSuccess)
{
try
{
if (_Client == null)
{
_Client = new HttpClient();
_Client.BaseAddress = new Uri("http://" + Constants.SERVER_URL + '/');
_Client.DefaultRequestHeaders.Accept.Clear();
_Client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
_Client.Timeout = TimeSpan.FromSeconds(30);
}
HttpResponseMessage HResponse = null;
string HSubUrl = GetSubUrl(_MsgType);
if (IsGetCall(_MsgType))
{
HResponse = _Client.GetAsync(HSubUrl).Result;
}
else
{
var HPostContent = new StringContent(_Data, Encoding.UTF8, "application/json");
HResponse = _Client.PostAsync(HSubUrl, HPostContent).Result;
}
string HContent = await HResponse.Content.ReadAsStringAsync();
HandleServerResponse(HContent, _MsgType, _OnSuccess);
}
#pragma warning disable CS0168 // Variable is declared but never used
catch (Exception _Exception)
#pragma warning restore CS0168 // Variable is declared but never used
{
_Client = null;
HandleServerResponse("error", _MsgType, _OnSuccess);
}
}
public bool SendPacket(EMessageTypes type, int seqID, string func, List <byte[]> args)
{
using (MemoryStream dataStream = new MemoryStream())
{
var dataWriter = new BinaryWriter(dataStream);
dataWriter.Write((byte)type);
dataWriter.Write(seqID);
dataWriter.Write(func);
dataWriter.Write(args.Count);
foreach (byte[] arg in args)
{
dataWriter.Write(arg.Length);
dataWriter.Write(arg);
}
dataWriter.Dispose();
return(Send(dataStream.ToArray()));
}
}
private static void HandleServerResponse(string _Answer, EMessageTypes _MsgType, Delegate _OnSuccess)
{
if (_Answer == "error")
{
// Silent Handling of Error Answer
switch (_MsgType)
{
case EMessageTypes.MSG_SEND_USER_DATA:
FileService.SetStorageEntry(Constants.STORAGE_KEY_USER_NOT_SEND, FileService.GetUserData());
break;
}
}
switch (_MsgType)
{
case EMessageTypes.MSG_LOAD_REFERENTS:
List <Referent> HReferents = new List <Referent>();
if (_Answer != "error")
{
HReferents = JsonConvert.DeserializeObject <List <Referent> >(_Answer);
HReferents.RemoveAll(r => r.IDENT == 1);
}
else
{
Device.BeginInvokeOnMainThread(() => NotificationService.ShowAlert(Messages.ERROR, Messages.ERROR_AT_LOADING, Messages.CLOSE));
}
Device.BeginInvokeOnMainThread(() => (_OnSuccess as OnLoadReferentsSuccess)(HReferents));
break;
case EMessageTypes.MSG_LOAD_STANDS:
List <Stand> HStands = new List <Stand>();
if (_Answer != "error")
{
HStands = JsonConvert.DeserializeObject <List <Stand> >(_Answer);
Device.BeginInvokeOnMainThread(() => (_OnSuccess as OnLoadStandsSuccess)(HStands));
}
else
{
Device.BeginInvokeOnMainThread(() => NotificationService.ShowAlert(Messages.ERROR, Messages.ERROR_AT_LOADING, Messages.CLOSE));
}
break;
case EMessageTypes.MSG_LOAD_ALL_EVENTS:
List <Event> HEvents = new List <Event>();
if (_Answer != "error")
{
HEvents = JsonConvert.DeserializeObject <List <Event> >(_Answer);
HEvents.Sort(delegate(Event _A, Event _B) {
return(_A.START_AS_DATE.CompareTo(_B.START_AS_DATE));
});
foreach (Event HEvent in HEvents)
{
// Referents setzen
HEvent.GenerateReferent();
HEvent.IsInbound = (HEvents.IndexOf(HEvent) % 2) == 0;
}
}
else
{
Device.BeginInvokeOnMainThread(() => NotificationService.ShowAlert(Messages.ERROR, Messages.ERROR_AT_LOADING, Messages.CLOSE));
}
Device.BeginInvokeOnMainThread(() => (_OnSuccess as OnLoadEventsSuccess)(HEvents));
break;
case EMessageTypes.MSG_LOAD_BREAKOUT_SESSION:
List <Event> HBreakoutEvents = new List <Event>();
if (_Answer != "error")
{
HBreakoutEvents = JsonConvert.DeserializeObject <List <Event> >(_Answer);
foreach (Event HEvent in HBreakoutEvents)
{
// Referents setzen
HEvent.GenerateReferent();
}
}
else
{
Device.BeginInvokeOnMainThread(() => NotificationService.ShowAlert(Messages.ERROR, Messages.ERROR_AT_LOADING, Messages.CLOSE));
}
Device.BeginInvokeOnMainThread(() => (_OnSuccess as OnLoadEventsSuccess)(HBreakoutEvents));
break;
case EMessageTypes.MSG_LOAD_USER_EVENTS:
List <Event> HPersonalEvents = new List <Event>();
if (_Answer != "error")
{
HPersonalEvents = JsonConvert.DeserializeObject <List <Event> >(_Answer);
HPersonalEvents.Sort(delegate(Event _A, Event _B) {
return(_A.START_AS_DATE.CompareTo(_B.START_AS_DATE));
});
foreach (Event HPersonalEvent in HPersonalEvents)
{
// Referents setzen
if (HPersonalEvent.CAN_BE_RESERVED)
{
HPersonalEvent.USER_HAS_RESERVED = true;
}
HPersonalEvent.GenerateReferent();
HPersonalEvent.IsInbound = (HPersonalEvents.IndexOf(HPersonalEvent) % 2) == 0;
}
}
else
{
if (_Answer != "error")
{
}
else
{
}
}
Device.BeginInvokeOnMainThread(() => (_OnSuccess as OnLoadEventsSuccess)(HPersonalEvents));
break;
case EMessageTypes.MSG_SEND_USER_DATA:
if (FileService.DoesStorageEntryExist(Constants.STORAGE_KEY_USER_NOT_SEND))
{
FileService.RemoveStorageEntry(Constants.STORAGE_KEY_USER_NOT_SEND);
}
break;
case EMessageTypes.MSG_CHECK_UNLOCK_KEY:
Device.BeginInvokeOnMainThread(() => (_OnSuccess as OnHandleCheckCustomerKey)(_Answer));
break;
case EMessageTypes.MSG_SEND_RESERVATION:
Device.BeginInvokeOnMainThread(() => (_OnSuccess as OnCommunicationSuccess)(_Answer));
break;
case EMessageTypes.MSG_LOAD_NOTIFICATIONS:
List <Notification> HNotifications = new List <Notification>();
if (_Answer != "error")
{
HNotifications = JsonConvert.DeserializeObject <List <Notification> >(_Answer);
}
Device.BeginInvokeOnMainThread(() => (_OnSuccess as OnLoadNotificationsSuccess)(HNotifications));
break;
case EMessageTypes.MSG_SEND_FEEDBACK:
Device.BeginInvokeOnMainThread(() => (_OnSuccess as OnCommunicationSuccess)(_Answer));
break;
case EMessageTypes.MSG_LOAD_SINGLE_EVENT:
Device.BeginInvokeOnMainThread(() => (_OnSuccess as OnCommunicationSuccess)(_Answer));
break;
default:
throw new NotImplementedException();
}
}
public static void SendTo(Vehicle origin, Vehicle destination, string message, EMessageTypes type)
{
if (type == EMessageTypes.Default)
{
Timestamp.MessagesSent++;
}
else if (type == EMessageTypes.Join)
{
Timestamp.JoinMessagesSent++;
}
else if (type == EMessageTypes.Kick)
{
Timestamp.KickMessagesSent++;
}
var str = origin.ReceiveFrom(destination, destination.ReceiveFrom(origin, message));
}
public BaseMessage(EMessageTypes messageType)
{
MessageType = messageType;
Guid = System.Guid.NewGuid().ToString();
}
public AuthMessage(EMessageTypes messageType, string username, string password) : base(messageType)
{
Username = username;
Password = password;
}
