/// <summary>
/// Sends a message asynchronously.
/// </summary>
/// <param name="buffer">The buffer.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task.</returns>
public async Task SendAsync(byte[] buffer, CancellationToken cancellationToken)
{
if (buffer == null)
{
throw new ArgumentNullException("buffer");
}
cancellationToken.ThrowIfCancellationRequested();
// Per msdn docs, attempting to send simultaneous messages will result in one failing.
// This should help us workaround that and ensure all messages get sent
await _sendSemaphore.WaitAsync(cancellationToken).ConfigureAwait(false);
try
{
await _socket.SendAsync(buffer, true, cancellationToken);
}
catch (OperationCanceledException)
{
_logger.Info("WebSocket message to {0} was cancelled", RemoteEndPoint);
throw;
}
catch (Exception ex)
{
_logger.ErrorException("Error sending WebSocket message {0}", ex, RemoteEndPoint);
throw;
}
finally
{
_sendSemaphore.Release();
}
}
public void SendText(string text, Action <bool> callback = null)
{
if (_ws == null || !_ws.IsOpen())
{
Debug.LogWarning("Web socket is not available to send text message. Try connecting?");
return;
}
_ws.SendAsync(text, callback);
}
/// <summary>
/// Sends a message asynchronously.
/// </summary>
/// <param name="buffer">The buffer.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task.</returns>
public Task SendAsync(byte[] buffer, CancellationToken cancellationToken)
{
if (buffer == null)
{
throw new ArgumentNullException("buffer");
}
cancellationToken.ThrowIfCancellationRequested();
return(_socket.SendAsync(buffer, true, cancellationToken));
}
private void Send()
{
if (Sending == false)
{
if (msg.Count() > 0)
{
Sending = true;
Msg m = msg.Dequeue();
if (m != null)
{
byte[] buf = m.Serialize_Msg();
if (socket.CheckConnect())
{
socket.SendAsync(buf, (ok) =>
{
if (ok)
{
Sending = false;
}
});
}
else
{
msg.Enqueue(m);
}
}
}
}
}//end send
private async void WebSocket_Opened(object sender, EventArgs e)
{
try
{
await _webSocket.SendAsync("PING");
await _webSocket.SendAsync("SUB" + '\t' + _broadcastKey);
MessageReceived?.Invoke(this, new MirrativConnected(""));
}
catch (Exception ex)
{
_logger.LogException(ex);
//SendSystemInfo(ex.Message, InfoType.Error);
}
}
public async Task SendMessageAsync(
Stream messageStream,
CancellationToken cancellationToken)
{
await _webSocket
.SendAsync(messageStream, cancellationToken)
.ConfigureAwait(false);
}
protected async Task SendAsync(string message)
{
if (_webSocket.WebSocketState != JsonRpcWebSocketState.Open)
{
return;
}
await _webSocket.SendAsync(message).ConfigureAwait(false);
}
public async Task SendMessageAsync(IWebSocket socket, ISendMessage message)
{
var buffer = deserializer.SerializeToBuffer(message);
logger.LogInformation($"Sending msg: {message.GetType()}");
if (socket.State == WebSocketState.Open)
{
await socket.SendAsync(buffer, WebSocketMessageType.Text,
true, CancellationToken.None);
}
}
public async Task SendMessageAsync(IWebSocket socket, string message)
{
if (socket.State != WebSocketState.Open)
{
return;
}
await socket.SendAsync(buffer : new ArraySegment <byte>(array: Encoding.Default.GetBytes(message),
offset: 0,
count: message.Length),
messageType : WebSocketMessageType.Text,
endOfMessage : true,
cancellationToken : CancellationToken.None);
}
private async void WebSocket_Opened(object sender, EventArgs e)
{
try
{
var msg = Create();
await _webSocket.SendAsync(msg);
//MessageReceived?.Invoke(this, new MildomConnected(""));
}
catch (Exception ex)
{
_logger.LogException(ex);
//SendSystemInfo(ex.Message, InfoType.Error);
}
}
private async void WebSocket_Opened(object sender, EventArgs e)
{
try
{
var guestInfo = (AnonymousUserInfo)MyInfo;
var msg = CreateFirstMessage(RoomId, guestInfo.GuestName, guestInfo.GuestId);
var bytes = InternalMessage.InternalMessageParser.EnctyptMessage(msg);
await _webSocket.SendAsync(bytes);
//MessageReceived?.Invoke(this, new MildomConnected(""));
}
catch (Exception ex)
{
_logger.LogException(ex);
//SendSystemInfo(ex.Message, InfoType.Error);
}
}
/// <summary>
/// Sends the message throught the open websocket.
/// </summary>
/// <returns>The async.</returns>
/// <param name="message">Message.</param>
public async Task SendAsync <TKrakenMessage>(TKrakenMessage message, CancellationToken cancellationToken = default)
where TKrakenMessage : class, IKrakenMessage
{
if (webSocket.State == WebSocketState.Open)
{
var jsonMessage = serializer.Serialize(message);
logger?.LogTrace("Trying to send: {@message}", jsonMessage);
var messageBytes = DEFAULT_ENCODING.GetBytes(jsonMessage);
await webSocket.SendAsync(new ArraySegment <byte>(messageBytes), WebSocketMessageType.Text, true, cancellationToken);
logger?.LogTrace("Successfully sent: {@message}", jsonMessage);
return;
}
logger?.LogWarning("WebSocket is not open. Current state: {state}",
webSocket.State);
}
private async Task SendBatteryStatus(HttpTransporterContext _, IWebSocket webSocket)
{
while (true)
{
var status = ReadWMIBattery();
byte[] data = Encoding.ASCII.GetBytes(JsonConvert.SerializeObject(status));
Console.WriteLine("Battery Status: {0}", status.ChargeLevel);
await webSocket.SendAsync(new ArraySegment <byte>(data, 0, data.Length), WebSocketMessageType.Text, endOfMessage : true, CancellationToken.None);
try
{
await webSocket.ReceiveAsync(data, CancellationToken.None);
}
catch (WebSocketException) { break; }
Thread.Sleep(1000);
}
}
/// <summary>
/// Sends all unsent messages
/// </summary>
public void Send()
{
var unsentFileNames = new List <string>();
try
{
var fileNames = messageQueue.DequeueAllFileNames();
unsentFileNames = fileNames.ToList();
foreach (var fileName in fileNames)
{
using (var fileMessage = messageQueue.GetMessage(fileName))
{
webSocket.SendAsync(fileMessage.Message);
}
unsentFileNames.Remove(fileName);
}
}
catch (Exception) // TODO check which exceptions can happen
{
messageQueue.RequeueAllFileNames(unsentFileNames);
}
}
private void OnGUI()
{
var scale = Screen.width / 800f;
GUI.matrix = Matrix4x4.TRS(new Vector3(0, 0, 0), Quaternion.identity, new Vector3(scale, scale, 1));
var width = GUILayout.Width(Screen.width / scale - 10);
WebSocketState state = socket == null ? WebSocketState.Closed : socket.ReadyState;
GUILayout.Label("SDK Version: 2.5.0", width);
var stateColor = state == WebSocketState.Closed ? "red" : state == WebSocketState.Open ? "#11ff11" : "#aa4444";
var richText = new GUIStyle()
{
richText = true
};
GUILayout.Label(string.Format(" <color=white>State:</color> <color={1}>{0}</color>", state, stateColor), richText);
GUI.enabled = state == WebSocketState.Closed;
GUILayout.Label("Address: ", width);
address = GUILayout.TextField(address, width);
GUILayout.BeginHorizontal();
GUI.enabled = state == WebSocketState.Closed;
if (GUILayout.Button(state == WebSocketState.Connecting ? "Connecting..." : "Connect"))
{
socket = new WebSocket(address);
socket.OnOpen += Socket_OnOpen;
socket.OnMessage += Socket_OnMessage;
socket.OnClose += Socket_OnClose;
socket.OnError += Socket_OnError;
AddLog(string.Format("Connecting...\n"));
socket.ConnectAsync();
}
GUI.enabled = state == WebSocketState.Open;
if (GUILayout.Button(state == WebSocketState.Closing ? "Closing..." : "Close"))
{
AddLog(string.Format("Closing...\n"));
socket.CloseAsync();
}
GUILayout.EndHorizontal();
GUILayout.Label("Text: ");
sendText = GUILayout.TextArea(sendText, GUILayout.MinHeight(50), width);
GUILayout.BeginHorizontal();
if (GUILayout.Button("Send"))
{
if (!string.IsNullOrEmpty(sendText))
{
socket.SendAsync(sendText);
if (logMessage)
{
AddLog(string.Format("Send: {0}\n", sendText));
}
sendCount += 1;
}
}
if (GUILayout.Button("Send Bytes"))
{
if (!string.IsNullOrEmpty(sendText))
{
var bytes = System.Text.Encoding.UTF8.GetBytes(sendText);
socket.SendAsync(bytes);
if (logMessage)
{
AddLog(string.Format("Send Bytes ({1}): {0}\n", sendText, bytes.Length));
}
sendCount += 1;
}
}
if (GUILayout.Button("Send x100"))
{
if (!string.IsNullOrEmpty(sendText))
{
for (int i = 0; i < 100; i++)
{
var text = (i + 1).ToString() + ". " + sendText;
socket.SendAsync(text);
if (logMessage)
{
AddLog(string.Format("Send: {0}\n", text));
}
sendCount += 1;
}
}
}
if (GUILayout.Button("Send Bytes x100"))
{
if (!string.IsNullOrEmpty(sendText))
{
for (int i = 0; i < 100; i++)
{
var text = (i + 1).ToString() + ". " + sendText;
var bytes = System.Text.Encoding.UTF8.GetBytes(text);
socket.SendAsync(bytes);
if (logMessage)
{
AddLog(string.Format("Send Bytes ({1}): {0}\n", text, bytes.Length));
}
sendCount += 1;
}
}
}
GUILayout.EndHorizontal();
GUI.enabled = true;
GUILayout.BeginHorizontal();
logMessage = GUILayout.Toggle(logMessage, "Log Message");
GUILayout.Label(string.Format("Send Count: {0}", sendCount));
GUILayout.Label(string.Format("Receive Count: {0}", receiveCount));
GUILayout.EndHorizontal();
if (GUILayout.Button("Clear"))
{
log = "";
receiveCount = 0;
sendCount = 0;
}
scrollPos = GUILayout.BeginScrollView(scrollPos, GUILayout.MaxHeight(Screen.height / scale - 270), width);
GUILayout.Label(log);
GUILayout.EndScrollView();
}
private void OnGUI()
{
var scale = Screen.width / 800f;
GUI.matrix = Matrix4x4.TRS(new Vector3(0, 0, 0), Quaternion.identity, new Vector3(scale, scale, 1));
var width = GUILayout.Width(Screen.width / scale - 10);
WebSocketState state = socket == null ? WebSocketState.Closed : socket.ReadyState;
GUILayout.BeginHorizontal();
GUILayout.Label("SDK Version: " + Settings.VERSION, GUILayout.Width(Screen.width / scale - 100));
GUI.color = green;
GUILayout.Label($"FPS: {fps:F2}", GUILayout.Width(80));
GUI.color = Color.white;
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Label("State: ", GUILayout.Width(36));
GUI.color = WebSocketState.Closed == state ? red : WebSocketState.Open == state ? green : wait;
GUILayout.Label($"{state}", GUILayout.Width(120));
GUI.color = Color.white;
GUILayout.EndHorizontal();
GUI.enabled = state == WebSocketState.Closed;
GUILayout.Label("Address: ", width);
address = GUILayout.TextField(address, width);
GUILayout.BeginHorizontal();
GUI.enabled = state == WebSocketState.Closed;
if (GUILayout.Button(state == WebSocketState.Connecting ? "Connecting..." : "Connect"))
{
socket = new WebSocket(address);
socket.OnOpen += Socket_OnOpen;
socket.OnMessage += Socket_OnMessage;
socket.OnClose += Socket_OnClose;
socket.OnError += Socket_OnError;
AddLog(string.Format("Connecting..."));
socket.ConnectAsync();
}
GUI.enabled = state == WebSocketState.Open;
if (GUILayout.Button(state == WebSocketState.Closing ? "Closing..." : "Close"))
{
AddLog(string.Format("Closing..."));
socket.CloseAsync();
}
GUILayout.EndHorizontal();
GUILayout.Label("Message: ");
sendText = GUILayout.TextArea(sendText, GUILayout.MinHeight(50), width);
GUILayout.BeginHorizontal();
if (GUILayout.Button("Send") && !string.IsNullOrEmpty(sendText))
{
socket.SendAsync(sendText);
AddLog(string.Format("Send: {0}", sendText));
sendCount += 1;
}
if (GUILayout.Button("Send Bytes") && !string.IsNullOrEmpty(sendText))
{
var bytes = System.Text.Encoding.UTF8.GetBytes(sendText);
socket.SendAsync(bytes);
AddLog(string.Format("Send Bytes ({1}): {0}", sendText, bytes.Length));
sendCount += 1;
}
if (GUILayout.Button("Send x100") && !string.IsNullOrEmpty(sendText))
{
for (int i = 0; i < 100; i++)
{
var text = (i + 1).ToString() + ". " + sendText;
socket.SendAsync(text);
AddLog(string.Format("Send: {0}", text));
sendCount += 1;
}
}
if (GUILayout.Button("Send Bytes x100") && !string.IsNullOrEmpty(sendText))
{
for (int i = 0; i < 100; i++)
{
var text = (i + 1).ToString() + ". " + sendText;
var bytes = System.Text.Encoding.UTF8.GetBytes(text);
socket.SendAsync(bytes);
AddLog(string.Format("Send Bytes ({1}): {0}", text, bytes.Length));
sendCount += 1;
}
}
GUILayout.EndHorizontal();
GUI.enabled = true;
GUILayout.BeginHorizontal();
logMessage = GUILayout.Toggle(logMessage, "Log Message");
GUILayout.Label(string.Format("Send Count: {0}", sendCount));
GUILayout.Label(string.Format("Receive Count: {0}", receiveCount));
GUILayout.EndHorizontal();
if (GUILayout.Button("Clear"))
{
log = "";
receiveCount = 0;
sendCount = 0;
}
scrollPos = GUILayout.BeginScrollView(scrollPos, GUILayout.MaxHeight(Screen.height / scale - 270), width);
GUILayout.Label(log);
GUILayout.EndScrollView();
}
public void SendAsync(string data)
{
_rawSocket.SendAsync(data);
}
public void SendAsync(string data, Action completed = null)
{
_rawSocket.SendAsync(data, completed);
}
