private static IWebsocket CreateSocket()
{
bool open = false;
bool closed = true;
IWebsocket obj = Mock.Of <IWebsocket>();
var socket = Mock.Get(obj);
socket.Setup(s => s.Close()).Returns(Task.FromResult(true)).Callback(() =>
{
var closing = socket.Object.IsOpen;
open = false; closed = true;
if (closing)
{
socket.Raise(s => s.OnClose += null);
}
OnClose?.Invoke(socket);
});
socket.Setup(s => s.IsOpen).Returns(() => open);
socket.Setup(s => s.Send(It.IsAny <string>())).Callback(new Action <string>((data) =>
{
OnSend?.Invoke(socket, data);
}));
socket.Setup(s => s.IsClosed).Returns(() => closed);
socket.Setup(s => s.Connect()).Returns(Task.FromResult(true)).Callback(() =>
{
socket.Setup(s => s.IsOpen).Returns(() => open);
socket.Setup(s => s.IsClosed).Returns(() => closed);
open = true; closed = false;
socket.Raise(s => s.OnOpen += null);
OnOpen?.Invoke(socket);
});
return(socket.Object);
}
private void SendCallBack(IAsyncResult asyncResult)
{
Socket socket = (Socket)asyncResult.AsyncState;
socket.EndSend(asyncResult);
OnSend?.Invoke(socket.RemoteEndPoint);
}
public void Send(Message message)
{
message.Send = true;
message.To.Messages.Add(message);
message.To.NewMessage(message);
OnSend?.Invoke(this, new OnSendEventArgs(message.ReadMessage(this), message.From.Username, message.To.Username));
}
void ProcessSend(SocketAsyncEventArgs e)
{
if (OnSendCallback != null)
{
OnSendCallback.Invoke();
}
}
protected override async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
if (this._apiKey != null)
{
request.Headers.Add("X-Api-Key", this._apiKey);
}
IEndpoint endpoint = request.Properties.ContainsKey("Endpoint") ? (IEndpoint)request.Properties["Endpoint"] : null;
if (endpoint?.RequireAuth == true || (authInfo != null))
{
if (!request.Headers.Contains("Authorization"))
{
request.Headers.Add("Authorization", $"Bearer {authInfo.AccessToken}");
}
}
// Dispatch to on send listeners
OnSend?.Invoke(this, request, endpoint);
//
HttpResponseMessage response = await base.SendAsync(request, cancellationToken);
// Dispatch to on response listeners
OnResponse?.Invoke(this, response, endpoint);
return(response);
}
public void Update(int pendingPackets)
{
if (pendingPackets == 0)
{
OnSend?.Invoke(0, _memory);
}
}
private async void NewClient(Socket socket, int millisecondsDelay)
{
try
{
socket.Connect(address);
OnConnect?.Invoke(this, new EventArgs());
}
catch (Exception exception)
{
OnConnectException?.Invoke(this, new ExceptionEventArgs(socket, exception));
}
while (true)
{
try
{
socket.Send(messageBuffer);
OnSend?.Invoke(this, new EventArgs());
}
catch (Exception exception)
{
OnSendException?.Invoke(this, new ExceptionEventArgs(socket, exception));
}
await Task.Delay(millisecondsDelay);
}
}
private void SendCallback(IAsyncResult ar)
{
// Retrieve the callback from the state object.
OnSend onSend = (OnSend)ar.AsyncState;
try {
// Complete sending the data to the remote device.
int bytesSent = sock.EndSend(ar);
onSend.Invoke(bytesSent);
} catch (Exception e) {
LogUtil.Error("ClientSocket.SendCallback: " + e.ToString());
onSend.Invoke(-1);
}
}
// method send bijna volledig aangepast = Ondelivering kan invoke zijn als passedTime < totamTimeSendingInt is en OnSend als passedTime == totalTimeSendingInt
private void Send()
{
// 10 "minutes" = 1 second
Thread.Sleep(100);
if (passedTime < totalTimeSendingInt)
{
passedTime++;
}
totalTimeSending = currentDelivery.TravelTime * currentDelivery.Factor;
totalTimeSendingInt = Decimal.ToInt32(totalTimeSending);
remainingTime = totalTimeSendingInt - passedTime;
if (OnDelivering != null)
{
OnDelivering?.Invoke(this, new DeliveryEventArgs(passedTime, remainingTime, totalTimeSendingInt));
}
if (passedTime == totalTimeSendingInt)
{
if (OnSend != null)
{
OnSend?.Invoke(this, new DeliveryEventArgs(passedTime, remainingTime, totalTimeSendingInt));
}
}
}
public static void Send <T>(T Event) where T : BaseEvent
{
if (EventList_.ContainsKey(Event.EventName))
{
((EventListenerImpl <T>)EventList_[Event.EventName]).Trigger(Event);
OnSend?.Invoke(Event);
}
}
private void HandleOutput(long output)
{
_outputQueue.Enqueue(output);
if (_outputQueue.Count == 3)
{
OnSend?.Invoke((int)_outputQueue.Dequeue(), new Packet(_outputQueue.Dequeue(), _outputQueue.Dequeue()));
}
}
private void WorkThreadFunction()
{
while (true)
{
OnSpeed?.Invoke(this, Data.GetSpeed());
OnHeartRate?.Invoke(this, Data.GetHeartRate());
OnSend?.Invoke(this, 0);
Thread.Sleep(1000);
}
}
public async Task SendAsync(IClient toClient, string message, IClient fromClient)
{
if (toClient.WebSocket.State != WebSocketState.Open)
{
return;
}
await toClient.WebSocket.SendAsync(message);
OnSend?.Invoke(this, new SocketSentEventArgs(toClient, fromClient, message));
}
/// <summary>
/// 发送回调
/// </summary>
/// <param name="e">操作对象</param>
private void ProcessSend(SocketAsyncEventArgs e)
{
if (e.SocketError != SocketError.Success)
{
return;
}
m_sendPool.Push(e);
OnSend?.Invoke(e.RemoteEndPoint, e.BytesTransferred);
}
// notify about new send telegram
public virtual void NotifySend(Telegram tel)
{
try
{
OnSend?.Invoke(tel);
}
catch (Exception e)
{
Log.AddLog(Log.Severity.EXCEPTION, Name, nameof(NotifyRcv), e.Message);
}
}
protected override void Start()
{
base.Start();
_btnSend.onClick.AddListener(() =>
{
OnSend?.Invoke();
});
_btnAlreadyAccount.onClick.AddListener(() =>
{
OnAlreadyAccount?.Invoke();
});
}
public void SendMessage(User sender, Message message)
{
if (this == sender)
{
Console.WriteLine("Нельзя отправить сообщение отправителю.");
return;
}
message.Sender = sender;
message.Reciver = this;
message.SendTime = DateTime.Now;
OnSend?.Invoke(this, message);
OnRecive?.Invoke(this, message);
}
private void SendCallBack(IAsyncResult asyncResult)
{
//Socket socket = (Socket)asyncResult.AsyncState;
TCPConnection client = (TCPConnection)asyncResult.AsyncState;
if (!client.Socket.Connected)
{
return;
}
client.Socket.EndSend(asyncResult);
//if(OnSend != null)
OnSend?.Invoke(client.Socket.RemoteEndPoint, responseData);
}
public async Task SendAsync(IClient toClient, string message, IClient fromClient)
{
try
{
if (toClient?.WebSocket == null || toClient.WebSocket.State != WebSocketState.Open)
{
return;
}
await toClient.WebSocket.SendAsync(message);
OnSend?.Invoke(this, new SocketSentEventArgs(toClient, fromClient, message));
}
catch (Exception e)
{
// most probable cause is a secondary thread disposing the client and the websocket before sending the message
_logger.LogDebug($"Message to {toClient?.Id} from {fromClient?.Id} has not been sent: {e}");
}
}
private void SendAsync(byte[] messageBuffer, bool useExceptionList)
{
byte[] messageBytes = Buffer.AddSplitter(messageBuffer, 0);
try
{
Socket.Send(messageBytes);
OnSend?.Invoke(this, new EventArgs());
}
catch (Exception exception)
{
if (useExceptionList)
{
CheckException(exception);
}
else
{
OnSendException?.Invoke(this, new ExceptionEventArgs(Socket, exception));
}
}
}
/// <summary>
/// Отправка сообщения
/// </summary>
public async Task Send(string sendingData)
{
if (curSocket.State != WebSocketState.Open)
{
return;
}
try
{
byte[] encoded = Encoding.UTF8.GetBytes(sendingData);
await curSocket.SendAsync(new ArraySegment <byte>(encoded, 0, encoded.Length), WebSocketMessageType.Text, true, CancellationToken.None);
OnSend?.Invoke(this, new SendEventArgs {
Data = data.ToString()
});
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
private void SendNotification(JObject payload, string deviceToken, BarkMessage barkMessage)
{
if (apnsBroker == null)
{
return;
}
if (deviceToken.Length != DeviceTokenLength)
{
return;
}
try
{
// 队列发送一个通知
apnsBroker.QueueNotification(new ApnsNotification
{
DeviceToken = deviceToken,//这里的deviceToken是ios端获取后传递到数据库统一记录管理的，有效的Token才能保证推送成功
Payload = payload
});
OnSend?.Invoke(this, new SendEventArgs(payload, deviceToken, barkMessage));
}
catch (Exception) { }
}
private void TimerCallBack(object sender, ElapsedEventArgs e)
{
OnSend?.Invoke(this, 0);
}
public void Send(IMQTTMessage message) => OnSend?.Invoke(message);
protected void FireOnSend(byte[] b, int length)
{
OnSend?.Invoke(this, b, length);
}
private void Send_Button_Click(object sender, RoutedEventArgs e)
{
OnSend?.Invoke(sender, e, Send_Msg);
}
protected void SendHandler(ClientMsgEventArgs e)
{
OnSend?.Invoke(this, e);
}
public new int Send(byte[] bytes)
{
OnSend?.Invoke(new SocketData(bytes));
return(Send(bytes, bytes.Length, 0));
}
protected void SendHandler(ServerMsgEventArgs e)
{
OnSend?.Invoke(this, e);
}
protected override void OnSendBase(byte[] msg)
{
string data = Encoding.GetEncoding("Big5").GetString(msg);
OnSend?.Invoke(data);
}
