public async Task messagesGetHistory(IOutgoingMessage message)
{
try
{
var tmessage = (OutgoingMessage)message;
var request = new HistoryRequest
{
//offset = 0,
count = 1,
//user_id = "1556462",
peer_id = tmessage.peer_id,
//start_message_id = "0",
//rev = "1",
//extended =
//fields =
group_id = _options.groupId,
};
await vkService.sendRequest(request, "messages.getHistory", _options);
}
catch (Exception e)
{
_logger.Log(NLog.LogLevel.Error, e, "SendMessageAsync error");
}
}
/// <inheritdoc />
public void WriteToTransport(IOutgoingMessage <IOutgoingMessageType> message, ITransport transport, CancellationToken cancellationToken = default)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
if (transport == null)
{
throw new ArgumentNullException(nameof(transport));
}
if (!(message is EnableContinuousUpdatesMessage enableContinuousUpdatesMessage))
{
throw new ArgumentException($"Message is no {nameof(EnableContinuousUpdatesMessage)}.", nameof(message));
}
cancellationToken.ThrowIfCancellationRequested();
// Message size
const int messageSize = 1 + sizeof(byte) + 4 * sizeof(ushort);
// Allocate buffer
Debug.Assert(messageSize <= 1024, "messageSize <= 1024");
Span <byte> buffer = stackalloc byte[messageSize];
// Message header
buffer[0] = Id;
// Enable?
buffer[1] = (byte)(enableContinuousUpdatesMessage.Enable ? 1 : 0);
// Rectangle
Rectangle rectangle = enableContinuousUpdatesMessage.Rectangle;
BinaryPrimitives.WriteUInt16BigEndian(buffer[2..], (ushort)rectangle.Position.X);
/// <inheritdoc />
public void WriteToTransport(IOutgoingMessage <IOutgoingMessageType> message, ITransport transport, CancellationToken cancellationToken = default)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
if (transport == null)
{
throw new ArgumentNullException(nameof(transport));
}
if (!(message is KeyEventMessage keyEventMessage))
{
throw new ArgumentException($"Message is no {nameof(KeyEventMessage)}.", nameof(message));
}
cancellationToken.ThrowIfCancellationRequested();
Span <byte> buffer = stackalloc byte[8];
// Message type
buffer[0] = Id;
// Down flag (followed by two bytes padding)
buffer[1] = (byte)(keyEventMessage.DownFlag ? 1 : 0);
// Keysym
BinaryPrimitives.WriteUInt32BigEndian(buffer[4..], (uint)keyEventMessage.KeySymbol);
/// <inheritdoc />
public void WriteToTransport(IOutgoingMessage <IOutgoingMessageType> message, ITransport transport, CancellationToken cancellationToken = default)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
if (transport == null)
{
throw new ArgumentNullException(nameof(transport));
}
if (!(message is PointerEventMessage pointerEventMessage))
{
throw new ArgumentException($"Message is no {nameof(PointerEventMessage)}.", nameof(message));
}
cancellationToken.ThrowIfCancellationRequested();
// Get pointer position
var posX = (ushort)Math.Max(0, pointerEventMessage.PointerPosition.X);
var posY = (ushort)Math.Max(0, pointerEventMessage.PointerPosition.Y);
Span <byte> buffer = stackalloc byte[6];
// Message type
buffer[0] = Id;
// Pressed buttons mask
buffer[1] = (byte)pointerEventMessage.PressedButtons;
// Pointer position
BinaryPrimitives.WriteUInt16BigEndian(buffer[2..], posX);
public async Task <bool> SendMessageAsync(IOutgoingMessage message)
{
try
{
var tmessage = (OutgoingMessage)message;
var urlBuilder = new UriBuilder(_url)
{
Path = "method/messages.send",
Query = $"group_id={_groupId}&access_token={_token}&v={_apiVersion}"
};
var values = new Dictionary <string, string>
{
{ "random_id", tmessage.random_id },
{ "peer_id", tmessage.peer_id.ToString() },
{ "message", tmessage.message },
// { "attachment", "364384447" }
};
var content = new FormUrlEncodedContent(values);
var response = await _httpClient.PostAsync(urlBuilder.Uri, content);
var responseBody = await response.Content.ReadAsStringAsync();
return(true);
}
catch (Exception e)
{
_logger.Log(NLog.LogLevel.Error, e, "send error");
return(false);
}
}
/// <inheritdoc />
public void WriteToTransport(IOutgoingMessage <IOutgoingMessageType> message, ITransport transport, CancellationToken cancellationToken = default)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
if (transport == null)
{
throw new ArgumentNullException(nameof(transport));
}
if (!(message is SetDesktopSizeMessage setDesktopSizeMessage))
{
throw new ArgumentException($"Message is no {nameof(SetDesktopSizeMessage)}.", nameof(message));
}
cancellationToken.ThrowIfCancellationRequested();
// Execute the mutation
(Size size, IImmutableSet <Screen> layout) = setDesktopSizeMessage.MutationFunc.Invoke(_state.RemoteFramebufferSize, _state.RemoteFramebufferLayout);
// Calculate message size
int messageSize = 2 + 2 * sizeof(ushort) + 2 + layout.Count * (sizeof(uint) + 4 * sizeof(ushort) + sizeof(uint));
// Allocate buffer
Span <byte> buffer = messageSize <= 1024 ? stackalloc byte[messageSize] : new byte[messageSize];
// Message header
buffer[0] = Id;
buffer[1] = 0; // Padding
// Size
BinaryPrimitives.WriteUInt16BigEndian(buffer[2..], (ushort)size.Width);
/// <summary>
///
/// </summary>
/// <param name="message"></param>
public void Broadcast(IOutgoingMessage message)
{
foreach (var peer in subscribersList)
{
peer.SendMessage(message, DeliveryMethod.Reliable);
}
}
/// <summary>
/// This version is used to forward an incoming request to a server
/// </summary>
public ServerRequestContext(
IRequestContext requestContext,
IPAddress serverIpAddress,
ushort serverPort,
Scheme scheme)
{
_log = requestContext.Log;
_incoming = new IncomingMessage
{
Headers = requestContext.Incoming.Headers,
OnSendHeaders = requestContext.Incoming.OnSendHeaders,
Content = requestContext.Incoming.Content,
ContentLength = requestContext.Incoming.ContentLength,
Method = requestContext.Incoming.Method,
Scheme = scheme,
DomainName = requestContext.Incoming.DomainName,
Path = requestContext.Incoming.Path,
Query = requestContext.Incoming.Query,
SourceAddress = requestContext.Incoming.SourceAddress,
SourcePort = requestContext.Incoming.SourcePort,
DestinationAddress = serverIpAddress,
DestinationPort = serverPort
};
_outgoing = requestContext.Outgoing;
}
/// <inheritdoc />
public void WriteToTransport(IOutgoingMessage <IOutgoingMessageType> message, ITransport transport, CancellationToken cancellationToken = default)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
if (transport == null)
{
throw new ArgumentNullException(nameof(transport));
}
if (!(message is ClientFenceMessage clientFenceMessage))
{
throw new ArgumentException($"Message is no {nameof(ClientFenceMessage)}.", nameof(message));
}
cancellationToken.ThrowIfCancellationRequested();
// Message size
int messageSize = 1 + 3 + sizeof(uint) + sizeof(byte) + clientFenceMessage.Payload.Length;
// Allocate buffer
Debug.Assert(messageSize <= 1024, "messageSize <= 1024");
Span <byte> buffer = stackalloc byte[messageSize];
// Message header
buffer[0] = Id;
// Padding
buffer[1] = 0;
buffer[2] = 0;
buffer[3] = 0;
// Flags
BinaryPrimitives.WriteUInt32BigEndian(buffer[4..], (uint)clientFenceMessage.Flags);
public Task SendAsync(IOutgoingMessage message, IReceiptBehavior receiptBehavior)
{
return
(receiptBehavior.DecorateSendMessageTask(
_transport.SendMessage(new OutgoingMessageAdapter(receiptBehavior.DecorateMessage(message),
_destination))));
}
/// <summary>
/// Convert the message to a byte buffer.
/// </summary>
/// <param name="message">Message to be serialised.</param>
/// <returns>Message serialised as a byte buffer</returns>
internal static byte[] ToArray(IOutgoingMessage message)
{
using (var stream = new MemoryStream())
using (var writer = new BinaryWriter(stream))
{
message.Write(writer);
return(stream.ToArray());
}
}
public void SendMQ(object obj)
{
client.Connect();
IOutgoingMessage message = client.CreateMessage();
message.MessageData = GeneralHelper.SerializeObject(obj);
message.Send();
client.Disconnect();
}
/// <summary>
/// 发送消息
/// </summary>
/// <param name="MQContent">消息内容</param>
/// <param name="ServerName">接收端程序名，必须在服务端注册</param>
public void SendMQ(string MQContent)
{
client.Connect();
IOutgoingMessage message = client.CreateMessage();
message.MessageData = Encoding.UTF8.GetBytes(MQContent);
message.Send();
client.Disconnect();
}
// An acked messages expects an ack to be sent from the server, if the ack message is not received in time the message will be sent again.
// optimize wait time by only sending message again when waiting time > rtt
public void SendAckedMessage(IOutgoingMessage messageToSend, byte messageAckIdToWaitFor, Action <byte[]> onAckMessageReceivedCallback)
{
IDisposable messageReceiveDisposable = udpClient.OnMessageReceive
.Where(message => message[0] == messageAckIdToWaitFor)
.Subscribe(OnMessageReceived);
pendingAckMessages.Add(new AckMessageAwaitData(messageAckIdToWaitFor, messageReceiveDisposable, messageToSend, onAckMessageReceivedCallback));
udpClient.SendMessage(messageToSend.GetBytes());
}
public override async Task SendMessageAsync(IChatSession sess, IOutgoingMessage msg)
{
if (!(sess is ChatSession))
{
throw new Exception("Bad chat session type");
}
var s = sess as ChatSession;
switch (msg.Type)
{
case MsgOutType.Text:
{
var m = new TextMessage
{
Text = msg.Text,
Receiver = s.InternalChatId
};
await _cli.SendTextMessageAsync(m);
break;
}
case MsgOutType.Keyboard:
{
var keyboardMsg = new KeyboardMessage
{
Text = msg.Text,
Receiver = s.InternalChatId,
Keyboard = GetViberKeyboard(msg.Keyboard.Buttons.ToArray()),
MinApiVersion = 3
};
await _cli.SendKeyboardMessageAsync(keyboardMsg);
break;
}
case MsgOutType.Photo:
break;
case MsgOutType.Wait:
{
var m = new TextMessage
{
Text = $"Нагадування встановлено",
Receiver = s.InternalChatId
};
await _cli.SendTextMessageAsync(m);
break;
}
default:
break;
}
}
/// <summary>
/// Respond with a message
/// </summary>
/// <param name="message"></param>
/// <param name="statusCode"></param>
public void Respond(IOutgoingMessage message, ResponseStatus statusCode = ResponseStatus.Default)
{
message.Status = statusCode;
if (AckResponseId.HasValue)
{
message.AckResponseId = AckResponseId.Value;
}
Peer.SendMessage(message, DeliveryMethod.Reliable);
}
public async Task <string> messagesGetConversationsAsync(IOutgoingMessage message)
{
try
{
return(await vkService.sendRequest(message, "messages.getConversations", _options));
}
catch (Exception e)
{
_logger.Log(NLog.LogLevel.Error, e, "SendMessageAsync error");
return(null);
}
}
/// <summary>
///
/// </summary>
/// <param name="message"></param>
/// <param name="condition"></param>
public void Broadcast(IOutgoingMessage message, Func <IPeer, bool> condition)
{
foreach (var peer in subscribersList)
{
if (!condition(peer))
{
continue;
}
peer.SendMessage(message, DeliveryMethod.Reliable);
}
}
/// <summary>
/// Sends a message to peer
/// </summary>
/// <param name="message">Message to send</param>
/// <param name="responseCallback">Callback method, which will be invoked when peer responds</param>
/// <param name="timeoutSecs">If peer fails to respons within this time frame, callback will be invoked with timeout status</param>
/// <param name="deliveryMethod">Delivery method</param>
/// <returns></returns>
public int SendMessage(IOutgoingMessage message, ResponseCallback responseCallback, int timeoutSecs, DeliveryMethod deliveryMethod)
{
if (!IsConnected)
{
responseCallback.Invoke(ResponseStatus.NotConnected, null);
return(-1);
}
var id = RegisterAck(message, responseCallback, timeoutSecs);
SendMessage(message, deliveryMethod);
return(id);
}
/// <summary>
/// 发送消息
/// </summary>
/// <param name="MQContentList">消息内容数组</param>
/// <param name="ServerName">接收端程序名，必须在服务端注册</param>
public void SendMQ(List <string> MQContentList)
{
client.Connect();
IOutgoingMessage message = client.CreateMessage();
foreach (string mqc in MQContentList)
{
message.MessageData = Encoding.UTF8.GetBytes(mqc);
message.Send();
}
client.Disconnect();
}
public async Task <bool> SendMessageAsync(IOutgoingMessage message)
{
try
{
var tmessage = (OutgoingMessage)message;
return(await vkService.messagesSendAsync(tmessage, _groupId, _token, _apiVersion));
}
catch (Exception e)
{
_logger.Log(NLog.LogLevel.Error, e, "SendMessageAsync error");
return(false);
}
}
public async Task <string> sendMessageAsync(IOutgoingMessage message)
{
try
{
var tmessage = (OutgoingMessage)message;
return(await vkService.sendRequest(tmessage, "messages.send", _options));
}
catch (Exception e)
{
_logger.Log(NLog.LogLevel.Error, e, "SendMessageAsync error");
return(null);
}
}
public Task SendMessageAsync(IOutgoingMessage message)
{
try
{
this.Socket.Send(message.GetOutData());
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Environment.Exit(-1);
}
return(Task.CompletedTask);
}
/// <summary>
///
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
public static byte GenerateFlags(IOutgoingMessage message)
{
var flags = message.Flags;
if (message.AckRequestId.HasValue)
{
flags |= (byte)MessageFlag.AckRequest;
}
if (message.AckResponseId.HasValue)
{
flags |= (byte)MessageFlag.AckResponse;
}
return(flags);
}
public override void SendMessage(IOutgoingMessage message, DeliveryMethod deliveryMethod)
{
if (delayedMessages != null)
{
lock (delayedMessages)
{
if (delayedMessages != null)
{
delayedMessages.Enqueue(message.ToBytes());
return;
}
}
}
socket.Send(message.ToBytes());
}
public override void SendMessage(IOutgoingMessage message, DeliveryMethod deliveryMethod)
{
if (_delayedMessages != null)
{
lock (_delayedMessages)
{
if (_delayedMessages != null)
{
_delayedMessages.Enqueue(message.ToBytes());
return;
}
}
}
_session.SendData(message.ToBytes());
}
/// <inheritdoc />
public void EnqueueMessage <TMessageType>(IOutgoingMessage <TMessageType> message, CancellationToken cancellationToken = default)
where TMessageType : class, IOutgoingMessageType
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
if (_disposed)
{
throw new ObjectDisposedException(nameof(RfbMessageSender));
}
cancellationToken.ThrowIfCancellationRequested();
TMessageType messageType = GetAndCheckMessageType <TMessageType>();
// Add message to queue
_queue.Add(new QueueItem(message, messageType), cancellationToken);
}
/// <summary>
/// 发送消息
/// </summary>
/// <param name="MQContentList">消息内容数组</param>
/// <param name="ServerNameList">接收端程序名数组，必须在服务端注册</param>
public void SendMQ(List <string> MQContentList, List <string> ServerNameList)
{
if (MQContentList.Count == ServerNameList.Count)
{
client.Connect();
IOutgoingMessage message = client.CreateMessage();
for (int i = 0; i < MQContentList.Count; i++)
{
message.DestinationApplicationName = ServerNameList[i];
message.MessageData = Encoding.UTF8.GetBytes(MQContentList[i]);
message.Send();
}
client.Disconnect();
}
}
/// <summary>
/// Adds the <paramref name="message"/> to the send queue and returns a <see cref="Task"/> that completes when the message was sent.
/// </summary>
/// <param name="message">The message to send.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <typeparam name="TMessageType">The type of the message.</typeparam>
/// <remarks>Please ensure the outgoing message type is marked as being supported by both sides before sending it. See <see cref="RfbConnection.UsedMessageTypes"/>.</remarks>
public Task SendMessageAsync <TMessageType>(IOutgoingMessage <TMessageType> message, CancellationToken cancellationToken = default)
where TMessageType : class, IOutgoingMessageType
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
cancellationToken.ThrowIfCancellationRequested();
RfbConnectionContext?connection = _activeConnection;
if (connection?.MessageSender == null)
{
return(Task.CompletedTask);
}
return(connection.MessageSender.SendMessageAndWaitAsync(message, cancellationToken));
}
// This method will not catch exceptions so the BackgroundThread base class will receive them,
// raise a "Failure" and trigger a reconnect.
protected override void ThreadWorker(CancellationToken cancellationToken)
{
try
{
Debug.Assert(_context.Transport != null, "_context.Transport != null");
ITransport transport = _context.Transport;
// Iterate over all queued items (will block if the queue is empty)
foreach (QueueItem queueItem in _queue.GetConsumingEnumerable(cancellationToken))
{
IOutgoingMessage <IOutgoingMessageType> message = queueItem.Message;
IOutgoingMessageType messageType = queueItem.MessageType;
if (_logger.IsEnabled(LogLevel.Debug))
{
string?parametersOverview = message.GetParametersOverview();
_logger.LogDebug("Sending {messageName} message ({parameters})...", messageType.Name, parametersOverview ?? "no parameters");
}
try
{
// Write message to transport stream
messageType.WriteToTransport(message, transport, cancellationToken);
queueItem.CompletionSource?.SetResult(null);
}
catch (Exception ex)
{
// If something went wrong during sending, tell the waiting tasks about it (so for example the GUI doesn't wait forever).
queueItem.CompletionSource?.TrySetException(ex);
// Send-thread should still fail
throw;
}
}
}
catch
{
// When the loop was canceled or failed, cancel all remaining queue items
SetQueueCancelled();
throw;
}
}
public bool IsSameDestination(IOutgoingMessage other)
{
var msg = (Message)other;
return msg != null && Object.Equals(TargetSilo, msg.TargetSilo);
}
/// <summary>
/// Creates an instance of <see cref="PersistentHeaderDecorator"/>
/// that wraps the given <paramref name="child"/>.
/// </summary>
/// <param name="child"></param>
public PersistentHeaderDecorator(IOutgoingMessage child)
: base(child)
{
}
/// <summary>
/// Decorates the given <paramref name="message"/>
/// with a <see cref="ReceiptHeaderDecorator"/>.
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
public IOutgoingMessage DecorateMessage(IOutgoingMessage message)
{
return new ReceiptHeaderDecorator(message, _destination, Interlocked.Increment(ref _messageSequence));
}
public OutgoingMessageAdapter(IOutgoingMessage outgoingMessage, string destination)
{
_outgoingMessage = outgoingMessage;
_destination = destination;
}
/// <summary>
/// Creates an instance of <see cref="TransactionHeaderDecorator"/>
/// for the given <paramref name="child"/> and <paramref name="transactionId"/>.
/// </summary>
/// <param name="child"></param>
/// <param name="transactionId"></param>
public TransactionHeaderDecorator(IOutgoingMessage child, int transactionId)
: base(child)
{
_transactionId = transactionId;
}
public IOutgoingMessage DecorateMessage(IOutgoingMessage message)
{
return message;
}
/// <summary>
/// Creates an instance of <see cref="HeaderDecorator"/>
/// that wraps the given <paramref name="child"/>
/// </summary>
/// <param name="child"></param>
protected HeaderDecorator(IOutgoingMessage child)
{
_child = child;
}
/// <summary>
/// Creates an instance of <see cref="ReceiptHeaderDecorator"/>
/// with the given parameters.
///
/// The header value will be the <paramref name="destination"/>
/// and the <paramref name="messageSequence"/> joined with a period (".").
/// </summary>
/// <param name="message"></param>
/// <param name="destination"></param>
/// <param name="messageSequence"></param>
public ReceiptHeaderDecorator(IOutgoingMessage message, string destination, long messageSequence)
: base(message)
{
_destination = destination;
_messageSequence = messageSequence;
}