private void DataReceived(object sender, ReceiveEventArgs dpMessage)
{
lock(this) {
byte data = (byte)dpMessage.Message.ReceiveData.Read(typeof(byte));
message(data);
}
}
private void Listener_Receive(object sender, ReceiveEventArgs e)
{
//Cast event sender as ClientPeer
ListenerPeer sourcePeer = sender as ListenerPeer;
Logger.Log("Listener Peer is now receiving..." + DateTime.Now.ToString("dd/MMM/yyyy hh:mm:ss tt") + Environment.NewLine);
//Get the Message received
Iso8583Message incomingMessage = e.Message as Iso8583Message;
if (incomingMessage == null) return;
long sourceID = Convert.ToInt64(sourcePeer.Name); //where message is coming from
Iso8583Message receivedMessage = new TransactionManager().ValidateMessage(incomingMessage, Convert.ToInt32( sourceID));
sourcePeer.Send(receivedMessage);
sourcePeer.Close();
sourcePeer.Dispose();
}
protected void OnConnectComplete(object sender, SocketAsyncEventArgs e)
{
if (e.SocketError == SocketError.Success)
{
IsConnecting = true;
ReceiveEventArgs.SetBuffer(State.Buffer, 0, State.Buffer.Length);
Client.ReceiveAsync(ReceiveEventArgs);
if (Connected != null)
{
Connected(this, new AsyncConnectionEventArgs(null, this));
}
}
else
{
IsConnecting = false;
}
}
private void Client_MessageReached(object sender, ReceiveEventArgs e)
{
string dio = client.Controlstr; //e.Msg.ToString();
richTextBoxMessagefromDataConnectPro.Text = dio; //e.Msg.ToString();
/*JsonReader reader = new JsonTextReader(new StringReader(dio));
*
* while (reader.Read())
* {
* dio = reader.Value.ToString();
* }*/
json = (JObject)JsonConvert.DeserializeObject(dio);
Console.WriteLine(json["D0"]);
Console.WriteLine(json["D1"]);
//Console.WriteLine(e.Msg.ToString());
}
/// <summary>
/// 重新异步开始接受数据
/// </summary>
internal void SyncRecvData()
{
if (isClose || Socket == null || !Socket.Connected)
{
return;
}
#if !UNITY_IPHONE
lock (Socket)
#endif
{
var buff = DogBuffer.GetFromPool32K();
RecvBuffer = buff;
ReceiveEventArgs.SetBuffer(RecvBuffer.Bytes, 0, RecvBuffer.Bytes.Length);
Socket.ReceiveAsync(ReceiveEventArgs);
}
}
private void ListenerPeerReceive(object sender, ReceiveEventArgs e)
{
ListenerPeer listenerPeer = sender as ListenerPeer;
Iso8583Message message = e.Message as Iso8583Message;
if (message == null)
{
return;
}
//logger.Log("Receiving Message >>>>");
Processor processor = new Processor();
Iso8583Message response;
try
{
processor.LogTransaction(message);
if (message.IsReversalOrChargeBack())
{
response = processor.Process(message);
}
else
{
response = processor.Process(message);
}
processor.LogTransaction(response);
//logger.Log("Sending Response >>>>");
}
catch (Exception ex)
{
message.Fields.Add(39, "06");
message.SetResponseMessageTypeIdentifier();
processor.LogTransaction(message);
response = message;
//processor.LogTransaction(response);
//logger.Log("Error, Something went wrong somewhere");
}
listenerPeer.Send(response);
listenerPeer.Close();
listenerPeer.Dispose();
}
void server_OnReceive(object sender, ReceiveEventArgs e)
{
THOK.MCP.Message message = null;
if (null != protocol)
{
message = protocol.Parse(e.Message);
}
else
{
Logger.Error(string.Format("UDPService出错。原因：未能找到消息'{0}'的解析类", e.Message));
message = new THOK.MCP.Message(e.Message);
}
if (message.Parsed)
{
DispatchState(message.Command, message.Parameters);
}
}
private void ClientPeerOnReceive(object sender, ReceiveEventArgs e)
{
var clientPeer = sender as ClientPeer;
Logger.Log("Client Peer Receiving>>> " + clientPeer.Name);
Iso8583Message receivedMessage = e.Message as Iso8583Message;
SinkNode theSinkNode;
try
{
var theSender = sender as ClientPeer;
theSinkNode = new SinkNodeManager().GetById(Convert.ToInt32(theSender.Name));
}
catch (Exception)
{
Logger.Log(String.Format("Message from Unknown Sink Node: {0}", receivedMessage));
receivedMessage.SetResponseMessageTypeIdentifier();
receivedMessage.Fields.Add(39, "91"); //Issuer inoperative
clientPeer.Send(receivedMessage);
return;
}
bool isValidMti;
if (receivedMessage == null)
{
return;
}
string mtiDescription = MessageDefinition.GetMtiDescription(receivedMessage.MessageTypeIdentifier, "FEP", out isValidMti);
if (!isValidMti)
{
Logger.Log(String.Format("Invalid MTI response code {0}, {1}", receivedMessage, theSinkNode)); // work on this
clientPeer.Send(receivedMessage);
return;
}
string responseCode = receivedMessage.Fields[39].ToString();
string responseDescription = MessageDefinition.GetResponseDescription(responseCode);
string stan = receivedMessage.Fields[11].ToString();
clientPeer.Send(receivedMessage);
}
public ReceiveEventArgs send_and_receive_sync(byte[] buffer)
{
ReceiveEventArgs ret = new ReceiveEventArgs();
try
{
socket.Send(buffer);
byte[] rec_buf = new byte[data_len];
socket.Receive(rec_buf);
ret.data = rec_buf;
ret.time = DateTime.Now;
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
return(ret);
}
private static void ReceiveListener(object sender, ReceiveEventArgs e, SourceNode node)
{
Console.WriteLine($"Received message from {node.Name} node");
// Console.WriteLine("Message : "+ e.Message );
var msg = processor.ProcessMessage(e.Message as Iso8583Message, node);
// Console.WriteLine(msg.Fields[39].Value.ToString());
msg = RouteResponseToSource(sender as ListenerPeer, msg);
if (msg.Fields[39].Value.ToString().Equals("00"))
{
Console.WriteLine("Transaction Complete");
}
else
{
Console.WriteLine("Transaction Incomplete");
}
// processor.ProcessTransaction(e.Message as Iso8583Message, node.Id, sender as ListenerPeer, schemes);
}
private void OnReceived(object sender, ReceiveEventArgs e)
{
if (InvokeRequired)
{
BeginInvoke(new ReceivedEventHandler(OnReceived), sender, e);
}
else
{
try
{
TraceView.AppendText(GXCommon.ToHex((byte[])e.Data));
}
catch (Exception ex)
{
TraceView.AppendText(ex.Message);
}
}
}
/// <summary>
/// Show received data.
/// </summary>
private void gxTerminal1_OnReceived(object sender, ReceiveEventArgs e)
{
try
{
if (this.InvokeRequired)
{
this.BeginInvoke(new ReceivedEventHandler(OnReceived), sender, e);
}
else
{
OnReceived(sender, e);
}
}
catch (Exception Ex)
{
MessageBox.Show(Ex.Message);
}
}
protected virtual void OnDispose()
{
try
{
object data = DequeueSendMessage();
while (data != null)
{
if (data is IBuffer buffer)
{
BeetleX.Buffers.Buffer.Free(buffer);
}
data = DequeueSendMessage();
}
SendEventArgs?.Dispose();
SendEventArgs?.Clear();
ReceiveEventArgs?.Dispose();
ReceiveEventArgs?.Clear();
mReceiveArgs.Server = null;
mReceiveArgs.Session = null;
mBaseNetStream.Dispose();
if (mSslStream != null)
{
mSslStream.Dispose();
}
Server.CloseSession(this);
ListenHandler = null;
ReceiveDispatcher = null;
if (Packet != null)
{
Packet.Dispose();
}
((IDisposable)Tag)?.Dispose();
OnDisposeProperties();
((IDisposable)mToken)?.Dispose();
}
catch
{
}
finally
{
Tag = null;
mToken = null;
}
}
private void Client_ReceiveCompleted(object sender, ReceiveEventArgs args)
{
try
{
if (args.ByteLength > 0)
{
onBytesLengthReceived(args.ByteLength);
using (MemoryStream ms = new MemoryStream(args.ReceivedBytes))
{
int code = PacketBase.ReadInt(ms);
switch ((ParamCode)code)
{
case ParamCode.TimePeriods:
onVideoStoragePacket(VideoTimePeriodsPacket.Decode(ms));
break;
case ParamCode.VideoPacket:
onVideoPacket(VideoStreamsPacket.Decode(ms));
break;
case ParamCode.VideoBaseInfo:
onVideoBasePacket(VideoBasePacket.Decode(ms));
break;
case ParamCode.DownloadInfosAll:
onDownloadInfosAll(DownloadInfoExpandPacket.DecodeArray(ms));
break;
case ParamCode.DownloadInfosAdd:
onDownloadInfosAdd(DownloadInfoExpandPacket.Decode(ms));
break;
case ParamCode.DownloadInfoPart:
onDownloadInfoPart(DownloadInfoPartConverter.Decode(ms));
break;
}
}
}
}
catch (Exception ex)
{
onException(ex);
}
}
static void ReceiveEventHandler(object sender, ReceiveEventArgs args)
{
IncCurBytes(args.Data.Length);
IncCurCount(1);
switch (args.Event)
{
case 10:
break;
case 11:
//args.ReturnData = new byte[1];
//AddChannel(args.Channel);
break;
case 21:
_sBinParse.ReceiveEventHandler(sender, args);
break;
case 22:
_sXmlParse.ReceiveEventHandler(sender, args);
break;
case 23:
_sJsonParse.ReceiveEventHandler(sender, args);
break;
case 24:
_sSimpleParse.ReceiveEventHandler(sender, args);
break;
case 25:
_sStructMessageParse.ReceiveEventHandler(sender, args);
break;
case 26:
_sCustomParse.ReceiveEventHandler(sender, args);
break;
default:
break;
}
//Console.WriteLine("get event:{0}", args.Event);
}
private void ConnectComplate(object sender, SocketAsyncEventArgs asyncEventArgs)
{
ReceiveEventArgs.Completed -= ConnectComplate;
if (asyncEventArgs.SocketError == SocketError.Success)
{
ReceiveEventArgs.Completed += PacketProtocol.ReceiveComplate;
ReceiveEventArgs.SetBuffer(receiveBuffer, 0, receiveBuffer.Length);
ConnectSocket = asyncEventArgs.ConnectSocket;
StartReceiveAsync();
if (OnConnected != null)
{
OnConnected(asyncEventArgs, this);//响应连接成功事件
}
}
else
{
loger.Error(string.Format("连接{0}失败", remoteEndPoint));
}
}
private void Server_Received(object sender, ReceiveEventArgs e)
{
byte[] packet = e.Data;
if (packet[4] == 0x31 && packet[5] == 0x31)
{
// Door Information
packet[5] = 0x32;
server.Send(packet);
EnableButtons();
}
else if (packet[4] == 0x32 && packet[5] == 0x34)
{
if (BendingSequence == 1)
{
packet = new byte[]
{
0x39, 0x37, 0x39, 0x30, 0x33, 0x35, 0x46, 0x46,
0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
0x0D, 0x0A
};
server.Send(packet);
BendingSequence = 0;
DisableButtons();
}
else if (BendingSequence == 2)
{
packet = new byte[]
{
0x39, 0x37, 0x39, 0x30, 0x33, 0x35, 0x46, 0x46,
0x38, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
0x0D, 0x0A
};
server.Send(packet);
BendingSequence = 0;
DisableButtons();
}
else if (BendingSequence == 3)
{
BendingSequence = 0;
DisableButtons();
}
}
}
private void Receiver_OnReceive(object sender, ReceiveEventArgs e)
{
Command c = CommandHandler.GetCommand(CommandsArray, e.message);
if (c == null)
{
Debug.Log("Unknown command " + e.message, Logger.Level.Error);
}
c.Inject(this);
if (c is Ack)
{
bool received = SendOnAckReceived(c as Ack);
OnAckReceived?.Invoke(this, new CommandEventArgs()
{
command = c
});
}
else
{
Ack ack = new Ack(this)
{
message = e.message
};
string message = CommandHandler.CommandToString(ack);
new Sender(null, c.sourceIp, c.sourcePort, message).Send(false); // send ack
//if(!e.sourceIP.Equals(c.sourceIp) || e.sourcePort != c.sourcePort) {
// Debug.Log(string.Format("SourceIP not equals {0}:{1} != {2}:{3}", e.sourceIP, e.sourcePort, c.sourceIp, c.sourcePort), Logger.Level.Error);
//}
Debug.Log(string.Format("Command received {0}:{1} | {2}:{3} [{4}] - {5}: {6}", e.sourceIP, e.sourcePort, c.sourceIp, c.sourcePort, c.tag, c.type, e.message), Logger.Level.Command);
c.ExecuteCommand(); // execute command
OnCommandReceived?.Invoke(this, new CommandEventArgs()
{
command = c
}); // invoke event
AddContact(c.Source);
}
}
private void _client_ReceiveCompleted(object sender, ReceiveEventArgs args)
{
try
{
if (args.ByteLenght >= 4)
{
int code = BitConverter.ToInt32(args.ReceivedBytes, 0);
switch (code)
{
case StreamEntityCode.FfmpegHeader:
{
CurrentHeader = FfmpegStreamHeader.DeserializeTo(args.ReceivedBytes);
OnStreamHeaderRecieved(CurrentHeader);
}
break;
case StreamEntityCode.HikvHeader:
{
CurrentHeader = HikvStreamHeader.DeserializeTo(args.ReceivedBytes);
OnStreamHeaderRecieved(CurrentHeader);
}
break;
case StreamEntityCode.StreamData:
{
OnStreamDataReceived(StreamData.DeserializeTo(args.ReceivedBytes));
}
break;
case StreamEntityCode.RemoteError:
{
RemoteError re = RemoteError.DeserializeTo(args.ReceivedBytes);
OnErrorOccurred(new ErrorEventArgs(re.ErrorMessage, ErrorTypes.Receive));
}
break;
}
}
}
catch (Exception e)
{
OnErrorOccurred(new ErrorEventArgs($"从远程流媒体服务器获取到异常数据:{e.Message}", ErrorTypes.Receive));
}
}
private void Adapter_ReceiveCompleted(object sender, ReceiveEventArgs args)
{
if (args.ByteLength > 0)
{
SocketAdapter adapter = sender as SocketAdapter;
using (MemoryStream ms = new MemoryStream(args.ReceivedBytes))
{
int code = PacketBase.ReadInt(ms);
byte[] buffer = null;
switch ((ParamCode)code)
{
case ParamCode.TimePeriods:
buffer = getVideoTimePeriodsPacketBuffer(VideoBaseInfomParam.Decode(ms));
break;
case ParamCode.VideoPacket:
buffer = getVideoPacketBuffer(VideoDataParam.Decode(ms));
break;
case ParamCode.VideoBaseInfo:
VideoBaseInfomParam param = VideoBaseInfomParam.Decode(ms);
Common.Log.Logger.Default.Trace($"下载视频：{param.BeginTime} - {param.EndTime} - {param.VideoName} - {param.VideoId} - {param.StreamId} -- {adapter.RemoteEndPoint}");
_isDownload = true;
buffer = getVideoBasePacketBuffer(param);
break;
case ParamCode.StorageFlag:
onStorageFlag(StorageFlagParam.Decode(ms));
break;
case ParamCode.StorageFlagAll:
buffer = getStorageFlagAll();
Console.WriteLine("StorageFlagAll: {0}", buffer.Length);
break;
}
if (buffer != null)
{
adapter.Send(code, buffer);
}
}
}
}
void client_OnReceive(object sender, ReceiveEventArgs e)
{
IPacket packet;
try
{
packet = PacketManager.Parse(e.Bytes);
}
catch (Exception ex)
{
print("ERR could not parse packet, error: " + ex);
return;
}
if (EnableConsoleWriting)
{
print("RECV " + packet.GetType().Name);
}
call(packet);
}
/// <summary>
/// DataReceived event will be called back when server get message from client which connect to.
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
static void ReceiveEventHandler(object sender, ReceiveEventArgs args)
{
switch ((Event)args.Event)
{
case Event.PushMessage:
//Get OneWay message from server
if (args.Data != null)
{
try
{
Console.WriteLine(Encoding.UTF8.GetString(args.Data));
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
break;
}
}
private void Listener_Receive(object sender, ReceiveEventArgs e)
{
//Cast event sender as ClientPeer
ListenerPeer sourcePeer = sender as ListenerPeer;
Logger.Log("Listener Peer is now receiving..." + DateTime.Now.ToString("dd/MMM/yyyy hh:mm:ss tt") + Environment.NewLine);
//Get the Message received
Iso8583Message incomingMessage = e.Message as Iso8583Message;
if (incomingMessage == null)
{
return;
}
long sourceID = Convert.ToInt64(sourcePeer.Name); //where message is coming from
Iso8583Message receivedMessage = new TransactionManager().ValidateMessage(incomingMessage, Convert.ToInt32(sourceID));
sourcePeer.Send(receivedMessage);
sourcePeer.Close();
sourcePeer.Dispose();
}
/// <summary>
/// Show received data.
/// </summary>
private void OnReceived(object sender, ReceiveEventArgs e)
{
try
{
//We receive byte array from GXSerial and this must be changed to chars.
if (HexCB.Checked)
{
ReceivedText.Text += BitConverter.ToString((byte[])e.Data);
}
else
{
//Get received data as string.
ReceivedText.Text += System.Text.Encoding.ASCII.GetString((byte[])e.Data);
}
}
catch (Exception Ex)
{
MessageBox.Show(Ex.Message);
}
}
protected virtual void Dispose(bool disposing)
{
if (m_disposed)
{
return;
}
if (disposing)
{
//释放托管资源
m_connectSocket = null;
m_asyncReceiveBuffer = null;
ReceiveEventArgs.UserToken = null;
SendEventArgs.UserToken = null;
}
//释放非托管资源
ReceiveEventArgs.Dispose();
SendEventArgs.Dispose();
SendEvent.Dispose();
m_disposed = true;
}
private void SScanner_AfterReceive(object sender, ReceiveEventArgs e)
{
var l = ((ListRepairs2LoadAdapter)list.Adapter).ListElements;
var _index = l.FindIndex(p => p.UnitNumber == e.ReceivedData);
if (_index != -1)
{
l[_index].SetSelected(!l[_index].Selected);
list.InvalidateViews();
list.SetSelection(_index);
}
//for (var i = 0; i < list.Count - 1; i++)
//{
// if (list.GetItemAtPosition(i).ToString().Split('|')[1] == cDataWedge.HandleDecodeData(intent).Split('|')[0])
// {
// list.SetItemChecked(i, true);
// break;
// }
//}
}
private void OnReceived(object sender, ReceiveEventArgs e)
{
lock (m_MessageLocker)
{
ServerLogMessage message = m_MessagePool.Get();
int id = BitConverter.ToInt32(e.bytes, 0);
byte[] contentBytes = new byte[0];
if (e.bytes.Length > sizeof(int))
{
contentBytes = new byte[e.bytes.Length - sizeof(int)];
Array.Copy(e.bytes, sizeof(int), contentBytes, 0, contentBytes.Length);
}
message.ID = id;
message.Client = e.client;
message.Message = contentBytes;
m_ReceivedMessages.Add(message);
}
}
private void onReceived(object sender, ReceiveEventArgs args)
{
if (args.ByteLength > 0)
{
using (MemoryStream ms = new MemoryStream(args.ReceivedBytes))
{
int code = PacketBase.ReadInt(ms);
//Console.WriteLine("{0} - {1}", (ParamCode)code, args.ByteLength);
switch ((ParamCode)code)
{
case ParamCode.TimePeriods:
//接收所有有效视频分布
onTimePeriodsAll(VideoTimePeriodsPacket.Decode(ms).TimePeriods);
break;
case ParamCode.VideoBaseInfo:
//设置视频基本信息
onVideoBase(VideoBasePacket.Decode(ms));
break;
case ParamCode.DownloadProgress:
//接收推送的下载进度。
onTimePeriodsDownloaded(VideoTimePeriodsPacket.Decode(ms).TimePeriods);
break;
case ParamCode.VideoPacket:
//接收视频包数据流
onVideoStreams(VideoStreamsPacket.Decode(ms));
break;
case ParamCode.LocalDownloadPath:
onDownloadPathReceived(PacketBase.ReadString(ms));
break;
case ParamCode.Message:
onVideoMessageFeedback(MessagePacket.Decode(ms));
break;
}
}
}
}
/// <summary>
/// 关闭连接
/// </summary>
public void Close()
{
if (Socket != null)
{
if (Socket.Connected)
{
Socket.Close();
}
Socket.Dispose();
Socket = null;
}
if (SendEventArgs != null)
{
SendEventArgs.Completed -= OnSendCompleted;
SendEventArgs.UserToken = null;
SendEventArgs.Dispose();
}
SendEventArgs = null;
if (ReceiveEventArgs != null)
{
ReceiveEventArgs.UserToken = null;
ReceiveEventArgs.Dispose();
}
ReceiveEventArgs = null;
// 清理发送缓冲区
if (m_PendingBuffer.Count > 0)
{
foreach (var buff in m_PendingBuffer)
{
buff.Release();
}
m_PendingBuffer.Clear();
}
}
private async void SScanner_AfterReceive(object sender, ReceiveEventArgs e)
{
DisableReadings(sender);
if (Values.scannerIsBusy)
{
orderNumberET.Text = "";
return;
}
Values.scannerIsBusy = true;
//sScanner.AfterReceive -= SScanner_AfterReceive;
var _scan = e.ReceivedData;
if (_scan.Substring(0, 2) == "@@" && _scan.Substring(_scan.Length - 2, 2) == "##") //QRCODE
{
var _recordList = _scan.Split('|');
try
{
_scan = _recordList[3];
}
catch
{
Toast.MakeText(Activity, "Wrong reading.", ToastLength.Long).Show();
Values.iFt.pushInfo("Wrong reading.");
EnableReadings(sender);
Values.scannerIsBusy = false;
return;
}
}
orderNumberET.Text = _scan;
var _res = await ActionGo(_scan);
EnableReadings(sender);
if (_res)
{
orderNumberET.Tag = "SCAN";
}
Values.scannerIsBusy = false;
}
protected virtual void OnDispose()
{
try
{
object data = DequeueSendMessage();
while (data != null)
{
if (data is IBuffer)
{
((IBuffer)data).Free();
}
data = DequeueSendMessage();
}
if (SendEventArgs != null)
{
SendEventArgs.Dispose();
}
if (ReceiveEventArgs != null)
{
ReceiveEventArgs.Dispose();
}
mReceiveArgs.Server = null;
mReceiveArgs.Session = null;
mBaseNetStream.Dispose();
if (mSslStream != null)
{
mSslStream.Dispose();
}
Server.CloseSession(this);
Server = null;
ReceiveDispatcher = null;
if (Packet != null)
{
Packet.Dispose();
}
mProperties.Clear();
}
catch
{
}
}
private void Scanner_AfterReceive(object sender, ReceiveEventArgs e)
{
if (Values.gDRL.Processing)
{
return;
}
((FragmentActivity)sender).RunOnUiThread(() =>
{
elData.Enabled = false;
elData.Tag = "SCAN";
});
Values.gDRL.Context = (FragmentActivity)sender;
DataTransferManager.Active = false;
//LocatorService.Active = false;
try
{
Task.Run(async() => {
await Values.gDRL.Add(e.ReceivedData);
Values.gDRL.Processing = false;
DataTransferManager.Active = true;
//LocatorService.Active = true;
((FragmentActivity)sender).RunOnUiThread(() =>
{
elData.Enabled = true;
elData.Text = "";
});
});
//await Values.gDRL.Add(e.ReceivedData);
}
catch (Exception ex)
{
Values.gDRL.Processing = false;
DataTransferManager.Active = true;
//LocatorService.Active = true;
((FragmentActivity)sender).RunOnUiThread(() =>
{
Toast.MakeText(Activity, "Error reading scan." + ex.Message, ToastLength.Long).Show();
});
}
}
private void ClientPeerOnReceive(object sender, ReceiveEventArgs e)
{
var clientPeer = sender as ClientPeer;
Logger.Log("Client Peer Receiving>>> " + clientPeer.Name);
Iso8583Message receivedMessage = e.Message as Iso8583Message;
SinkNode theSinkNode;
try
{
var theSender = sender as ClientPeer;
theSinkNode = new SinkNodeManager().GetById(Convert.ToInt32(theSender.Name));
}
catch (Exception)
{
Logger.Log(String.Format("Message from Unknown Sink Node: {0}", receivedMessage));
receivedMessage.SetResponseMessageTypeIdentifier();
receivedMessage.Fields.Add(39, "91"); //Issuer inoperative
clientPeer.Send(receivedMessage);
return;
}
bool isValidMti;
if (receivedMessage == null) return;
string mtiDescription = MessageDefinition.GetMtiDescription(receivedMessage.MessageTypeIdentifier, "FEP", out isValidMti);
if (!isValidMti)
{
Logger.Log(String.Format("Invalid MTI response code {0}, {1}", receivedMessage, theSinkNode)); // work on this
clientPeer.Send(receivedMessage);
return;
}
string responseCode = receivedMessage.Fields[39].ToString();
string responseDescription = MessageDefinition.GetResponseDescription(responseCode);
string stan = receivedMessage.Fields[11].ToString();
clientPeer.Send(receivedMessage);
}
public void DataReceived(object sender, ReceiveEventArgs rea)
{
int senderID = rea.Message.SenderID;
//Ignore messages received before we are initialized
if ((gameState == GameStates.Loading) ||
(gameState == GameStates.Config)) {
rea.Message.ReceiveData.Dispose();
return;
}
byte mType = (byte)rea.Message.ReceiveData.Read(typeof(byte));
MessageType messageType = (MessageType)mType;
switch (messageType) {
case MessageType.PlayerUpdateID: {
PlayerUpdate update = (PlayerUpdate)rea.
Message.ReceiveData.Read(typeof(PlayerUpdate));
ShotUpdate shotUpdate = new ShotUpdate();
shotUpdate.ShotPosition = new Vector2[Constants.NumShots];
shotUpdate.ShotAge = new int[Constants.NumShots];
for (int i = 0; i < Constants.NumShots; i++) {
shotUpdate.ShotPosition[i] =
(Vector2)rea.Message.ReceiveData.Read(typeof(Vector2));
shotUpdate.ShotAge[i] =
(int)rea.Message.ReceiveData.Read(typeof(int));
}
rea.Message.ReceiveData.Dispose();
lock (otherPlayers) {
object playerObject = otherPlayers[senderID];
if (null == playerObject)
return;
RemotePlayer player = (RemotePlayer) playerObject;
Shot[] shotArray = new Shot[Constants.NumShots];
for (int i = 0; i < Constants.NumShots; i++) {
shotArray[i] = new Shot();
shotArray[i].Position = shotUpdate.ShotPosition[i];
shotArray[i].Age = shotUpdate.ShotAge[i];
}
player.Ship.ShotHandler.SetShotArray(shotArray);
player.Ship.Position = update.ShipPosition;
player.Ship.Outline = update.Outline;
player.Ship.Velocity = update.ShipVelocity;
player.Ship.State = update.State;
player.Ship.WaitCount = update.WaitCount;
player.Ship.DeathCount = update.DeathCount;
player.Ship.FlameIndex = update.FlameIndex;
player.Ship.Sounds = (Sounds)update.Sounds;
player.Ship.Score = update.Score;
player.UpdateTime = DateTime.Now;
player.Active = true;
otherPlayers[senderID] = player;
}
break;
}
case MessageType.GameParamUpdateID: {
GameParamUpdate update = (GameParamUpdate)rea.Message.
ReceiveData.Read(typeof(GameParamUpdate));
rea.Message.ReceiveData.Dispose();
gravity = update.Gravity;
gameSpeed = update.GameSpeed;
if (update.BounceBack != 0)
bounceBack = true;
else
bounceBack = false;
if (update.InverseGravity != 0)
inverseGravity = true;
else
inverseGravity = false;
if (update.BlackHole != 0)
blackHole = true;
else
blackHole = false;
Size newWindowSize = update.WindowSize;
Rectangle newBounds = new
Rectangle(this.windowBounds.Location, newWindowSize);
//Initialize(newBounds);
break;
}
case MessageType.Add1ToScore: {
rea.Message.ReceiveData.Dispose();
ship.Score += 1;
break;
}
case MessageType.Add2ToScore: {
rea.Message.ReceiveData.Dispose();
ship.Score += 2;
break;
}
case MessageType.GamePaused: {
rea.Message.ReceiveData.Dispose();
gameState = GameStates.Paused;
break;
}
case MessageType.GameRunning: {
rea.Message.ReceiveData.Dispose();
if (gameState == GameStates.Paused)
gameState = GameStates.Running;
break;
}
}
}
private void peer_Receive(object sender, ReceiveEventArgs e)
{
NetworkPacket packet = e.Message.ReceiveData;
PlayerInformation player = (PlayerInformation)playerList[e.Message.SenderID];
while(packet.Position < packet.Length)
{
NetworkMessageType messageType = (NetworkMessageType)(int)packet.Read(typeof(int));
switch(messageType)
{
case NetworkMessageType.ChatMessage:
string chatMessage = packet.ReadString();
this.MessageReceived(player, chatMessage);
break;
}
}
e.Message.ReceiveData.Dispose(); // We no longer need the data, Dispose the buffer
}
public void DataReceived(object sender, ReceiveEventArgs rea)
{
int senderID = rea.Message.SenderID;
//Ignore messages received before we are initialized
if ((gameState == GameStates.Loading) || (gameState == GameStates.Config)) {
rea.Message.ReceiveData.Dispose();
return;
}
byte mType = (byte)rea.Message.ReceiveData.Read(typeof(byte));
MessageType messageType = (MessageType)mType;
switch (messageType) {
case MessageType.PlayerUpdateID: {
PlayerUpdate update = (PlayerUpdate)rea.Message.ReceiveData.Read(typeof(PlayerUpdate));
ShotUpdate shotUpdate = new ShotUpdate();
shotUpdate.ShotPosition = new Vector3[Constants.NumShots];
shotUpdate.ShotAge = new float[Constants.NumShots];
shotUpdate.ShotAlive = new bool[Constants.NumShots];
for (int i = 0; i < Constants.NumShots; i++) {
shotUpdate.ShotPosition[i] = (Vector3)rea.Message.ReceiveData.Read(typeof(Vector3));
shotUpdate.ShotAge[i] = (int)rea.Message.ReceiveData.Read(typeof(int));
shotUpdate.ShotAlive[i] = (bool)rea.Message.ReceiveData.Read(typeof(bool));
}
rea.Message.ReceiveData.Dispose();
lock(opponentShip) {
opponentShip.Position.WorldMatrix = update.WorldMatrix;
opponentShip.Score = update.Score;
opponentShip.Sounds = (Sounds)update.Sounds;
opponentShip.WaitCount = update.WaitCount;
opponentShip.SetState((ShipState)update.State);
Photon[] shotArray = opponentShip.ShotHandler.GetShotArray();
for (int i = 0; i < Constants.NumShots; i++) {
shotArray[i].Location = shotUpdate.ShotPosition[i];
shotArray[i].Age = shotUpdate.ShotAge[i];
shotArray[i].Alive = shotUpdate.ShotAlive[i];
}
opponentShip.ShotHandler.SetShotArray(shotArray);
}
break;
}
case MessageType.Add1ToScore: {
rea.Message.ReceiveData.Dispose();
playerShip.Score += 1;
break;
}
case MessageType.GamePaused: {
rea.Message.ReceiveData.Dispose();
gameState = GameStates.Paused;
break;
}
case MessageType.GameRunning: {
rea.Message.ReceiveData.Dispose();
if (gameState == GameStates.Paused)
gameState = GameStates.Running;
break;
}
}
}
protected void OnReceiveComplete(ReceiveEventArgs arg)
{
if (arg.SocketError != System.Net.Sockets.SocketError.Success)
{
//Release back to the pool
arg.Socket = null;
_receivePool.PushBack(arg);
Close();
}
else if (arg.BytesTransferred == 0)
{
//Release back to the pool
arg.Socket = null;
_receivePool.PushBack(arg);
Close();
}
else
{
//receivedBytes += arg.BytesTransferred;
//lock (storeBuffer)
{
//var free = storeBuffer.Length - storeWriteOffset;
//if (free < arg.BytesTransferred)
//{
// throw new InvalidOperationException("Receive buffer has no room for this segment");
//}
//Migrate to the storeBuffer
//Array.Copy(receiveBuffer, arg.Offset, storeBuffer, storeWriteOffset, arg.BytesTransferred);
//storeWriteOffset += arg.BytesTransferred;
lock (_rxSyncRoot)
//lock (storeBuffer)
{
storeWriteOffset += arg.BytesTransferred;
var free = arg.Buffer.Length - storeWriteOffset;
if (free == 0)
{
//Move back to the start. This can overwrite data, so make sure terraria reading isn't slow!
storeWriteOffset = 0;
free = receiveBuffer.Length;
reset = true;
Console.WriteLine("Reader reset");
}
arg.SetBuffer(storeWriteOffset, free);
available += arg.BytesTransferred;
}
}
if (!_socket.ReceiveAsync(arg))
{
//The receive was processed synchronously which means the callback wont be executed.
OnReceiveComplete(arg);
}
}
}
