protected virtual void SendComplete(object sender, IOTaskCompleteEventArgs <SocketSendTask> e)
{
e.Task.Completed -= SendComplete;
var msg = (IPacket)e.Task.UserToken;
if (msg.Id == (byte)AresId.MSG_CHAT_SERVER_HTML)
{
}
if (e.Task.Exception == null)
{
Monitor.AddOutput(e.Task.Transferred);
try {
PacketSent?.Invoke(this, new PacketEventArgs(msg, MessageType, e.Task.Transferred));
if (IsConnected)
{
SendQueue();
}
}
catch (Exception ex) {
OnException(ex);
}
}
else
{
OnException(e.Task.Exception);
}
}
/// <summary>
/// Add a osc message to the send queue
/// </summary>
/// <param name="message">message to send</param>
public void Send(OscPacket message)
{
if (State != OscSocketState.Connected)
{
return;
}
queueEmpty.Reset();
if (sendQueue.Count >= messageBufferSize)
{
return;
}
sendQueue.Enqueue(message);
if (sendQueue.Count != 1)
{
return;
}
int size = message.Write(buffer);
if (Statistics != null)
{
message.IncrementSendStatistics(Statistics);
Statistics.BytesSent.Increment(size);
}
PacketSent?.Invoke(message);
Socket.BeginSend(buffer, 0, size, SocketFlags, Send_Callback, message);
}
static public void ReportSend(HidReport report)
{
HidReport hr = report;
hidDevice.WriteReport(hr, 1000000);
// raise event
PacketSent?.Invoke(hr);
}
public void SendPacket(IPacket packet)
{
using (var ms = new MemoryStream())
{
serializer.Serialize(ms, packet);
byte[] packetBytes = ms.ToArray();
SendData(packetBytes);
}
PacketSent?.Invoke(this, EventArgs.Empty);
}
private void Send_Callback(IAsyncResult ar)
{
bool shouldClose = false;
try
{
SocketError error;
Socket.EndSend(ar, out error);
shouldClose = Socket.Connected == false;
OscPacket packet;
if (sendQueue.TryDequeue(out packet) == false)
{
Debug.WriteLine("Could not dequeue packet");
return;
}
if (packet.IsSameInstance(ar.AsyncState as OscPacket) == false)
{
Debug.WriteLine("Queue packet and async objects do not match");
}
if (sendQueue.TryPeek(out packet) && State == OscSocketState.Connected)
{
int size = packet.Write(buffer);
PacketSent?.Invoke(packet);
Socket.BeginSend(buffer, 0, size, SocketFlags, Send_Callback, packet);
}
else
{
queueEmpty.Set();
}
}
catch
{
queueEmpty.Set();
}
finally
{
if (shouldClose == true)
{
Dispose();
}
}
}
static public void ReportSend(byte reportId, byte[] data)
{
HidReport hr;
byte[] buffer = new byte[data.Length + 1];
Array.ConstrainedCopy(data, 0, buffer, 1, data.Length);
hr = new HidReport(buffer.Length, new HidDeviceData(buffer, HidDeviceData.ReadStatus.Success));
hr.ReportId = (byte)reportId;
hidDevice.WriteReport(hr, 1000000);
// raise event
PacketSent?.Invoke(hr);
}
private void SendLoop()
{
Try(() =>
{
while (!IsDisposed)
{
var packet = Packets.Take();
Writer.Write((byte)0x02);
Writer.Write((byte)Registry.Register(packet.GetType()));
packet.WriteTo(Writer);
Writer.Write((byte)0x03);
Writer.Flush();
PacketSent?.Invoke(this, new PacketSentEventArgs(Connection, packet));
}
});
}
private void SendAsyncCallback(IAsyncResult ar)
{
try {
if (NetworkStream != null)
{
NetworkStream.EndWrite(ar);
if (PacketSent != null)
{
FrostbiteConnection.RaiseEvent(PacketSent.GetInvocationList(), this, (Packet)ar.AsyncState);
}
}
}
catch (SocketException) {
Shutdown();
}
catch (Exception) {
Shutdown();
}
}
private void SendComplete(object sender, IOTaskCompleteEventArgs <SocketSendTask> e)
{
e.Task.Completed -= sendHandler;
if (e.Task.Exception == null)
{
Monitor.AddOutput(e.Task.Transferred);
try {
var msg = (IPacket)e.Task.UserToken;
PacketSent?.Invoke(this, new PacketEventArgs(msg, WebSocketMessageType.Binary, e.Task.Transferred, e.Task.RemoteEndPoint));
}
catch (Exception ex) {
OnException(ex, e.Task.RemoteEndPoint);
}
}
else
{
OnException(e.Task.Exception, e.Task.RemoteEndPoint);
}
}
public async Task <EnOceanPacket> SendTelegram(EnOceanTelegram telegram)
{
_stream.Pause();
telegram.SetIdBase(_idBase.Span);
var packet = telegram.ToPacket();
PacketSent?.Invoke(this, new PacketSentEventArgs(packet, telegram));
_stream.WriteFrame(packet);
var p = await _stream.ReadFrame();
if (p != null)
{
AnswerReceived?.Invoke(this, new AnswerReceviedEventArgs(p));
}
_stream.Continue();
return(p);
}
public virtual void SendPacket(string packet, bool session)
{
if (!_disconnectHandled && Connected)
{
try
{
byte[] encrypted = Cryptography.Encrypt(packet, session);
Tcp.GetStream().Write(encrypted, 0, encrypted.Length);
PacketSent?.Invoke(packet);
}
catch (SocketException e)
{
Error?.Invoke(e);
if (Tcp != null)
{
_logger.Error($"TCP state - {Tcp.GetState()}");
}
_logger.Error(e);
Disconnnect();
}
catch (IOException e)
{
Error?.Invoke(e);
if (Tcp != null)
{
_logger.Error($"TCP state - {Tcp.GetState()}");
}
_logger.Error(e);
Disconnnect();
}
}
}
internal override void WritePacket(byte[] packet)
{
_stream.Write(packet, 0, packet.Length);
PacketSent?.Invoke(this, new McpPacket(packet));
}
public virtual void OnPacketSent(object sender, EventArgs e)
{
PacketSent?.Invoke(sender, e);
}
/// <summary>
/// Sends the specified <see cref="Rewtek.GameLibrary.Network.Packet"/>.
/// </summary>
/// <param name="packet">The <see cref="Rewtek.GameLibrary.Network.Packet"/> to send.</param>
/// <returns>The number of bytes sent to the <see cref="System.Net.Sockets.Socket"/>.</returns>
public int Send(Packet packet)
{
PacketSent.SafeInvoke(this, new PacketEventArgs(packet, PacketEventType.Send));
return(Send(packet.GetBytes()));
}
