/// <summary>
/// Data being sent to the serial port
/// </summary>
private void SerialPort_DataOut(ISerialPort sender, Queue <byte> DataBytes)
{
if (GeneratingEvents)
{
DataSent?.Invoke(sender, DataBytes);
}
}
internal void ProcessSend(SocketAsyncEventArgs Args)
{
T Session = (T)Args.UserToken;
if (Args.SocketError == SocketError.Success)
{
Session.SendBytesRemainingCount = Session.SendBytesRemainingCount - Args.BytesTransferred;
if (Session.SendBytesRemainingCount == 0)
{
SendPool.Push(Args);
}
else
{
Session.BytesSentAlreadyCount += Args.BytesTransferred;
StartSend(Args);
}
if (DataSent != null)
{
DataSent.Invoke(new SocketSentEventArgs <T>(Session, Session.DataToSend, Args.BytesTransferred));
}
}
else
{
CloseClientSocket(Args);
SendPool.Push(Args);
}
}
public void AddNetworkListeners(NetworkConnected netConCall, DataSent dataSentCall, DataReceived dataRecvCall, NetworkError netErrorCall)
{
OnNetworkConnected += netConCall;
OnDataSent += dataSentCall;
OnDataReceived += dataRecvCall;
OnNetworkError += netErrorCall;
}
DataSent PushData(int type, object data, int priority, MsgQueue.MessageProc proc)
{
List <OneQueue> qs = Receiver.Queues;
if (priority < 0 || priority >= qs.Count)
{
priority = qs.Count - 1;
}
object o = data;
OneQueue.Message msg = new OneQueue.Message();
msg.sender = this;
msg.Data = o;
msg.type = type;
mutex.WaitOne();
qs[priority].PushData(msg);
DataSent d = null;
if (type == MsgQueue.msgtype_Request)
{
d = new DataSent(msg);
sentMsgs.Add(d);
}
mutex.ReleaseMutex();
return(d);
}
public void SendMessage(DataBuffer data)
{
var bytes = data.ToBytes();
Connection.BeginSend(bytes, 0, bytes.Length, 0, OnSend, Connection);
DataSent?.Invoke(this, new ProviderDataEventArgs(null, false, null, bytes.Length));
}
internal async Task SendDataAsync(string data, CancellationToken token)
{
try
{
if (Disposed)
{
return;
}
_data = string.Copy(data);
await _writer.WriteAsync(_data);
_writer.Flush();
if (!_data.Contains("Alive") || TLCFIDataProvider.Default.Settings.LogAliveTrace)
{
_logger.Trace(" --> {0}", _data);
}
DataSent?.Invoke(this, _data);
}
catch (IOException)
{
Disconnected?.Invoke(this, new EventArgs());
}
catch
{
Disconnected?.Invoke(this, new EventArgs());
}
}
public virtual void SendByte(byte Data, bool RaiseEvent = true)
{
SendBuffer.Add(Data);
if (RaiseEvent)
{
DataSent?.Invoke(this);
}
}
public virtual void SendBytes(byte[] Data)
{
foreach (byte b in Data)
{
SendByte(b, false);
}
DataSent?.Invoke(this);
}
private void DataSentInvokeCallback(IAsyncResult ar)
{
try
{
DataSent?.EndInvoke(ar);
}
catch
{
}
}
/// <summary>
/// 发送消息并在本地处理
/// </summary>
/// <param name="data">数据</param>
/// <param name="priority">0:最高优先级，-1:最低优先级</param>
/// <param name="proc">调用方法</param>
/// <returns></returns>
public object ProcessData(object data, int priority, MsgQueue.MessageProc proc)
{
State = SenderState.Busy;
DataSent d = PushData(MsgQueue.msgtype_Request, data, priority, proc);
requestThread = Thread.CurrentThread;
d.evt.WaitOne();
requestThread = null;
State = SenderState.Idle;
return(d.retData);
}
internal void OnDataSent(byte[] buffer, int offset, int count)
{
try
{
DataSent?.Invoke(this, new DataEventArgs(buffer, offset, count));
}
catch (Exception ex)
{
exceptionFunc(new Exception("Exception thrown in user event", ex));
}
}
public Task Send(string message)
{
DataSent.Add(new NotificationData
{
Message = message,
Subject = "subject",
RecipientsEmail = "recipientEmail"
});
return(Task.CompletedTask);
}
public void SendMessage(DataBuffer data)
{
if (client != null)
{
NetOutgoingMessage outmsg = client.CreateMessage();
outmsg.Write(data.ToBytes());
client.SendMessage(outmsg, NetDeliveryMethod.ReliableSequenced);
DataSent?.Invoke(this, new ProviderDataEventArgs(null, false, data, data.GetLength()));
}
}
/// <summary>
/// 发送消息并请求响应
/// </summary>
/// <param name="data">数据</param>
/// <param name="priority">0:最高优先级，-1:最低优先级</param>
/// <returns></returns>
public object RequestData(object data, int priority)
{
State = SenderState.Waiting;
DataSent d = PushData(MsgQueue.msgtype_Request, data, priority, null);
requestThread = Thread.CurrentThread;
d.evt.WaitOne();
requestThread = null;
State = SenderState.Idle;
return(d.retData);
}
public void SendMessage(DataBuffer buffer)
{
var msg = buffer.ToBytes();
msg = Compress(msg);
client.GetStream().Write(BitConverter.GetBytes((Int16)msg.Length), 0, 2);
client.GetStream().Write(msg, 0, msg.Length);
client.GetStream().Flush();
DataSent?.Invoke(this, new ProviderDataEventArgs(null, false, null, msg.Length));
}
/// <summary>
/// Async callback when send is completed.
/// </summary>
/// <param name="ar">The asynchronous result.</param>
private void OnSendComplete(IAsyncResult ar)
{
try
{
socket.EndSend(ar);
DataSent?.Invoke(this, new ConnectionArgs(this));
}
catch
{
OnDisconnect();
}
}
private void ProcessSend(SocketAsyncEventArgs e)
{
ClientToken clientToken = (ClientToken)e.UserToken;
if (e.SocketError != SocketError.Success)
{
if (e.SocketError == SocketError.OperationAborted)
{
return;
}
//Fire DataSentError event
if (DataSendError != null)
{
if (CallDataSendErrorAsync)
{
DataSendError.BeginInvoke(this, r => DataSendError.EndInvoke(r), null);
}
else
{
DataSendError(this);
}
}
clientToken.ResetSend();
ProcessDisconnect(e);
}
clientToken.SendBytesRemaining = clientToken.SendBytesRemaining - e.BytesTransferred;
if (clientToken.SendBytesRemaining == 0)
{
//Fire DataSent event
if (DataSent != null)
{
if (CallDataSentAsync)
{
DataSent.BeginInvoke(this, r => DataSent.EndInvoke(r), null);
}
else
{
DataSent(this);
}
}
clientToken.ResetSend();
}
else
{
clientToken.BytesSentAlready += e.BytesTransferred;
StartSend();
}
}
//private
private void onSend(IAsyncResult r)
{
Socket socket = (Socket)r.AsyncState;
try {
socket.EndSendTo(r);
} catch (Exception ex) {
Error?.Invoke(this, new ExceptionEventArgs(ex));
}
DataSent?.Invoke(this, EventArgs.Empty);
sendNext();
}
private async void SendAsync(int msPeriodSend)
{
int msDataSending;
var sw = new Stopwatch();
while (true)
{
ShowMessage("Waiting for a connection...");
client = await server.AcceptTcpClientAsync();
ShowMessage("Connected!");
stream = client.GetStream();
int millisecondsDelay;
while (!cancelTokenSource.Token.IsCancellationRequested)
{
sw.Restart();
try
{
if (imageCollection.TryTake(out Bitmap bmp))
{
var data = await Task.Run(() => GrayImage.GrayImageToByte(bmp));
await stream.WriteAsync(data, 0, data.Length);
}
}
catch
{
client.Close();
ShowMessage("Client disconnected!");
break;
}
sw.Stop();
ShowMessage("Data sent!");
msDataSending = (int)sw.ElapsedMilliseconds;
DataSent?.Invoke(msDataSending);
millisecondsDelay = msPeriodSend - msDataSending;
if (millisecondsDelay > 0)
{
await Task.Delay(millisecondsDelay, cancelTokenSource.Token);
}
}
}
}
/// <summary>Asynchronous callback when a send completes successfully.</summary>
/// <param name="asyncResult">The asynchronous result.</param>
private void OnSendComplete(IAsyncResult asyncResult)
{
try
{
socket.EndSend(asyncResult);
// Raise our data sent event.
DataSent?.Invoke(this, new ConnectionArgs(this));
}
catch
{
OnConnectionDisconnect();
}
}
public void Send(string text)
{
byte[] data = Encoding.ASCII.GetBytes(text);
if (!_socket.Connected)
{
_socket.Connect(IPAddress.Parse(_address), _port);
Connected?.Invoke(null, EventArgs.Empty);
}
_socket.BeginSend(data, 0, data.Length, SocketFlags.None, (ar) =>
{
var bytes = _socket.EndSend(ar);
DataSent?.Invoke(this, text);
}, new object());
}
private void WritePort(string text, bool addOk = true)
{
_comm.WritePort(text);
if (DataSent != null)
{
DataSent.Invoke(this, text);
}
if (addOk && text != "ok")
{
_comm.WritePort("ok");
if (DataSent != null)
{
DataSent.Invoke(this, "ok");
}
}
}
//private
private void onSend(IAsyncResult r)
{
Socket socket = (Socket)r.AsyncState;
try {
socket.EndSend(r);
} catch (Exception ex) {
Error?.Invoke(this, new ExceptionEventArgs(ex));
Disconnect();
return;
}
DataSent?.Invoke(this, EventArgs.Empty);
if (IsConnected)
{
sendNext();
}
}
public void SendMessage(object recipientKey, DataBuffer buffer)
{
var msg = Compress(buffer.ToBytes());
try {
var tcpClient = recipientKey as TcpClient;
tcpClient.GetStream().Write(BitConverter.GetBytes((Int16)msg.Length), 0, 2);
tcpClient.GetStream().Write(msg, 0, msg.Length);
tcpClient.GetStream().Flush();
DataSent?.Invoke(this, new ProviderDataEventArgs(recipientKey, false, null, msg.Length));
} catch (Exception ex) {
if (connected.Contains(recipientKey as TcpClient))
{
DisconnectUser(recipientKey);
}
}
}
public void SendPlayerData(string playerData)
{
if (State == ClientState.Debug)
{
return;
}
if (State != ClientState.Connected)
{
throw new InvalidOperationException("Cannot send player data: client not connected");
}
DataStreamWriter writer = _clientDriver.BeginSend(_reliablePipeline, _clientToServerConnection);
writer.WriteInt(Commands.PlayerData);
writer.WriteManagedString(playerData);
_clientDriver.EndSend(writer);
DataSent?.Invoke(writer.Length);
}
public void SendPing()
{
if (State == ClientState.Debug)
{
return;
}
if (State != ClientState.Connected)
{
Debug.LogWarning($"Cannot send messages in client state {State}");
return;
}
DataStreamWriter writer = _clientDriver.BeginSend(_unreliablePipeline, _clientToServerConnection);
writer.WriteInt(Commands.Ping);
writer.WriteFloat(Time.time);
_clientDriver.EndSend(writer);
DataSent?.Invoke(writer.Length);
}
/// <summary>
/// Creates the TcpClientReader and TcpClientWriter
/// </summary>
/// <param name="remoteEndPoint">The remote server address</param>
private void FinalizeConnection(IPEndPoint remoteEndPoint)
{
_networkStream = _client.GetStream();
_reader = new TcpClientReader(_client);
_reader.OnException += Disconnect;
_reader.OnMessageReceived += OnMessageReceived;
_reader.Start();
_writer = new TcpClientWriter(_client);
_writer.OnException += Disconnect;
_writer.OnMessageSent += (message) => { DataSent?.Invoke(this, message); };
_writer.Start();
//Name = Guid.NewGuid().ToString() + "." + _client.Client.RemoteEndPoint.As<IPEndPoint>()?.Address.ToString() ?? "";
Name = RemoteEndPoint.ToString();
//var ipEndPoint = RemoteEndPoint;
//if (ipEndPoint != null)
// Name = ipEndPoint.Address.ToString() + ":" + ipEndPoint.Port.ToString();
}
public void Send(Packet data)
{
if (Stream == null || !_socket.Connected)
{
return;
}
Task.Run( // Initiate the sender thread
() => {
try {
byte[] buffer = data.SerializePacket();
Stream?.Write(buffer, 0, buffer.Length);
DataSent?.Invoke(this, data);
} catch (Exception ex) {
ConnectionLost?.Invoke(this, ex);
}
}
);
}
public async Task SendMessage(string message)
{
if (_underlyingWebSocket.State == WebSocketState.Open)
{
var bytes = Encoding.UTF8.GetBytes(message);
await _underlyingWebSocket.SendAsync(
new ArraySegment <byte>(bytes),
WebSocketMessageType.Text,
true,
CancellationToken.None
);
DataSent?.Invoke(this, new WebSocketDataEventArgs(message));
}
else
{
throw new InvalidOperationException("Cannot send data while websocket is not open.");
}
}
public void SendRPC(NetAsset netAsset, string methodName, object[] args)
{
if (State == ClientState.Debug)
{
return;
}
if (State != ClientState.Connected)
{
throw new InvalidOperationException($"Cannot send rpc {methodName}: not connected");
}
DataStreamWriter streamWriter = _clientDriver.BeginSend(_reliablePipeline, _clientToServerConnection);
streamWriter.WriteInt(Commands.NetAssetRPC);
streamWriter.WriteFloat(Server.Time);
streamWriter.WriteInt(netAsset.NetID);
netAsset.SerializeRPC(ref streamWriter, methodName, args);
_clientDriver.EndSend(streamWriter);
DataSent?.Invoke(streamWriter.Length);
}
public void AddNetworkListeners(NetworkConnected netConCall, DataSent dataSentCall, DataReceived dataRecvCall, NetworkError netErrorCall) {
OnNetworkConnected += netConCall;
OnDataSent += dataSentCall;
OnDataReceived += dataRecvCall;
OnNetworkError += netErrorCall;
}
