private async static Task Echo(HttpContext context, System.Net.WebSockets.WebSocket webSocket, IWebSocket i_webSocket, object instance, Type t)
{
while (webSocket.State == WebSocketState.Open)
{
try
{
SocketResult data = await i_webSocket.ReceiveAsync();
// string target = json["target"].ToString();
// string method = json["method"].ToString();
// SocketResult data = new SocketResult(target, method, json["data"]);
if (data.method == "on")//监听
{
i_webSocket.AddListener(data.target, i_webSocket);
}
else
{
t.GetMethod(data.method + "_" + data.target)?.Invoke(instance, new Object[] { context, data });
}
}
catch (Exception)
{
//context.Response.StatusCode = 404;
}
}
}
private async Task <string> ReadNextMessage(CancellationToken cancellationToken = default)
{
var buffer = new byte[1024];
var messageParts = new StringBuilder();
WebSocketReceiveResult result;
do
{
result = await webSocket.ReceiveAsync(new ArraySegment <byte>(buffer), cancellationToken);
if (result.MessageType == WebSocketMessageType.Close)
{
logger?.LogDebug("Closing connection to socket");
await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, cancellationToken);
logger?.LogDebug("Connection successfully closed");
// TODO: Disconnected-Event
}
else
{
var str = Encoding.UTF8.GetString(buffer, 0, result.Count);
messageParts.Append(str);
}
} while (!result.EndOfMessage);
var message = messageParts.ToString();
return(message);
}
public async Task ReceiveMessageAsync(
PipeWriter writer,
CancellationToken cancellationToken)
{
await _webSocket
.ReceiveAsync(writer, cancellationToken)
.ConfigureAwait(false);
}
//public List<IWebSocket> this[string metadata]
//{
// get
// {
// if (clientsByMetadata.ContainsKey(metadata))
// {
// return clientsByMetadata[metadata];
// }
// return new List<IWebSocket>();
// }
//}
private void OnHandShaken(IWebSocket webSocket, ClientHandshake clientHandshake)
{
var handler = handlerFactory.Create(clientHandshake.ResourceName);
if (handler != null)
{
webSocket.Received = handler.Received;
webSocket.Disconnected = sender =>
{
var found = clientsByMetadata.FirstOrDefault(kv => kv.Value.Exists(ws => ws == sender));
if (found.Value != null)
{
found.Value.Remove((WebSocket)sender);
if (!found.Value.Any())
{
clientsByMetadata.Remove(found.Key);
}
// A web socket with the metaData has been disconnected from the server
handler.Disconnected(found.Key);
}
};
webSocket.Error = handler.Error;
var metadata = GetMetadata(clientHandshake, webSocket);
// A web socket with the metaData has been connected to the server
handler.Connected(metadata);
if (!clientsByMetadata.ContainsKey(metadata))
{
clientsByMetadata.Add(metadata, new List <IWebSocket> {
webSocket
});
}
else
{
//clientsByMetaData[metaData].Dispose();
clientsByMetadata[metadata].Add(webSocket);
}
// Begin receiving data from the client
webSocket.ReceiveAsync();
}
else
{
if (Log.IsDebugEnabled)
{
Log.Debug("There was no handler found for the resource name");
}
// If nothing is handling client connections
// the client connection should be closed
webSocket.Dispose();
}
}
async Task IWebSocketConnection.HandleMessagesAsync(IWebSocket socket, CancellationToken cancellation)
{
WebSocket = socket;
_connectionManager.AddSession(this);
await OnConnected();
bool onDisconnectedInvoked = false;
while (WebSocket.WebSocketState == JsonRpcWebSocketState.Open)
{
var(type, buffer) = await WebSocket.ReceiveAsync(cancellation);
string message = null;
if (buffer.Array == null)
{
_connectionManager.RemoveSession(this);
const int invalidPayloadData = 1007;
await WebSocket.CloseAsync(invalidPayloadData, "Received empty data buffer");
throw new InvalidOperationException("Received empty data buffer from underlying socket");
}
if (type != MessageType.Binary)
{
message = Encoding.UTF8.GetString(buffer.Array, buffer.Offset, buffer.Count);
}
if (type == MessageType.Text)
{
await OnMessage(message);
}
else if (type == MessageType.Binary)
{
await OnBinaryMessage(buffer);
}
else if (type == MessageType.Close)
{
await OnDisconnected(CloseStatusCode.Normal, message);
onDisconnectedInvoked = true;
break;
}
else
{
throw new ArgumentOutOfRangeException();
}
}
_connectionManager.RemoveSession(this);
if (!onDisconnectedInvoked)
{
await OnDisconnected(CloseStatusCode.Normal, "Socket closed");
}
}
private static async Task Receive(IWebSocket socket, Action <WebSocketReceiveResult, byte[]> handleMessage)
{
byte[] buffer = new byte[1024 * 4];
while (socket.State == WebSocketState.Open)
{
WebSocketReceiveResult result = await socket.ReceiveAsync(buffer : new ArraySegment <byte>(buffer), cancellationToken : CancellationToken.None);
handleMessage(result, buffer);
buffer = new byte[1024 * 4];
}
}
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);
}
}
async Task IWebSocketConnection.HandleMessagesAsync(IWebSocket socket)
{
_webSocket = socket;
Sockets[socket.Id] = socket;
await OnConnected();
while (_webSocket.WebSocketState == JsonRpcWebSocketState.Open)
{
var(type, buffer) = await _webSocket.ReceiveAsync();
string message = null;
if (buffer.Array == null)
{
throw new InvalidOperationException("Received empty data buffer from underlying socket");
}
if (type != MessageType.Binary)
{
message = Encoding.UTF8.GetString(buffer.Array, buffer.Offset, buffer.Count);
}
switch (type)
{
case MessageType.Text:
await OnMessage(message);
break;
case MessageType.Binary:
await OnBinaryMessage(buffer);
break;
case MessageType.Close:
Sockets.Remove(_webSocket.Id);
await OnDisconnected(CloseStatusCode.Normal, message);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
}
public async Task ReceiveAsync(IWebSocket socket)
{
IPlayer player = new Player(socket);
collections.AddPlayer(player);
var buffer = new byte[1024 * 4];
try
{
while (socket.State == WebSocketState.Open)
{
var result = await socket.ReceiveAsync(buffer, CancellationToken.None);
await handler.HandleMessageAsync(player, result, buffer);
}
}
catch (WebSocketException e)
{
logger.LogInformation(e.Message);
}
await collections.RemovePlayer(player);
}
public Task ReceiveAsync()
{
return(_webSocket.ReceiveAsync());
}
public void Start()
{
Work = _webSocket.ReceiveAsync();
}
