private void Listen()
{
// Listen State
Task.Factory.StartNew(async() =>
{
while (true)
{
await Task.Delay(500);
if (_socket.State == WebSocketState.Aborted || _socket.State == WebSocketState.Closed)
{
if (State != SocketIOState.Closed)
{
State = SocketIOState.Closed;
_tokenSource.Cancel();
OnClosed?.Invoke(ServerCloseReason.Aborted);
}
}
}
}, _tokenSource.Token);
// Listen Message
Task.Factory.StartNew(async() =>
{
var buffer = new byte[ReceiveChunkSize];
while (true)
{
if (_socket.State == WebSocketState.Open)
{
WebSocketReceiveResult result = await _socket.ReceiveAsync(new ArraySegment <byte>(buffer), _tokenSource.Token);
if (result.MessageType == WebSocketMessageType.Text)
{
var builder = new StringBuilder();
string str = Encoding.UTF8.GetString(buffer, 0, result.Count);
builder.Append(str);
while (!result.EndOfMessage)
{
result = await _socket.ReceiveAsync(new ArraySegment <byte>(buffer), _tokenSource.Token);
str = Encoding.UTF8.GetString(buffer, 0, result.Count);
builder.Append(str);
}
var parser = new ResponseTextParser(_namespace, this)
{
Text = builder.ToString()
};
await parser.ParseAsync();
}
}
}
}, _tokenSource.Token);
}
private static async Task Receive(ClientWebSocket webSocket, Action <string> receiveAction)
{
byte[] buffer = new byte[2048];
while (webSocket.State == WebSocketState.Open)
{
try
{
var result = await webSocket.ReceiveAsync(new ArraySegment <byte>(buffer), CancellationToken.None);
if (result.MessageType == WebSocketMessageType.Close)
{
await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None);
}
else
{
var text = Encoding.UTF8.GetString(buffer).TrimEnd('\0');
if (!text.StartsWith("@hello@"))
{
var arr = text.Split(new string[] { "@_@" }, StringSplitOptions.None);
receiveAction("*" + arr[0]);
}
}
}
catch (Exception)
{
}
}
}
public string Recv()
{
ArraySegment <byte> bytesReceived = new ArraySegment <byte>(new byte[10240]);
Task <WebSocketReceiveResult> task = ws.ReceiveAsync(
bytesReceived, CancellationToken.None);
task.Wait();
WebSocketReceiveResult result = task.Result;
return(Encoding.UTF8.GetString(bytesReceived.Array, 0, result.Count));
}
private async Task <string> ReceiveFirst()
{
byte[] buffer = new byte[1024];
if (webSocket.State == WebSocketState.Open)
{
var result = await webSocket.ReceiveAsync(new ArraySegment <byte>(buffer), CancellationToken.None);
if (result.MessageType == WebSocketMessageType.Close)
{
await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None);
}
else
{
var text = Encoding.UTF8.GetString(buffer).TrimEnd('\0');
if (text.StartsWith("hostKey@"))
{
return(text.Replace("hostKey@", ""));
}
return(string.Empty);
}
}
return(string.Empty);
}
//private static async Task Send(ClientWebSocket webSocket)
//{
// while (webSocket.State == WebSocketState.Open)
// {
// string stringtoSend = Console.ReadLine();
// byte[] buffer = encoding.GetBytes(stringtoSend);
// await webSocket.SendAsync(new ArraySegment<byte>(buffer), WebSocketMessageType.Binary, false, CancellationToken.None);
// Console.WriteLine("Sent: " + stringtoSend);
// await Task.Delay(1000);
// }
//}
private static async Task ReceiveFirst(ClientWebSocket webSocket, Action <string> receiveAction)
{
byte[] buffer = new byte[1024];
if (webSocket.State == WebSocketState.Open)
{
var result = await webSocket.ReceiveAsync(new ArraySegment <byte>(buffer), CancellationToken.None);
if (result.MessageType == WebSocketMessageType.Close)
{
await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None);
}
else
{
var text = Encoding.UTF8.GetString(buffer).TrimEnd('\0');
receiveAction(text);
}
}
}
private async Task WatchForMessagesFromServer()
{
var buffer = new byte[ReceiveChunkSize];
try
{
while (_clientWebSocket.State == WebSocketState.Open)
{
var stringResult = new StringBuilder();
WebSocketReceiveResult result;
do
{
result = await _clientWebSocket.ReceiveAsync(new ArraySegment <byte>(buffer), _cancellationToken);
if (result.MessageType == WebSocketMessageType.Close)
{
await _clientWebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None);
CallOnDisconnected();
}
else
{
var str = Encoding.UTF8.GetString(buffer, 0, result.Count);
stringResult.Append(str);
}
} while (!result.EndOfMessage);
CallOnMessage(stringResult);
}
}
catch (Exception)
{
CallOnDisconnected();
}
finally
{
_clientWebSocket.Dispose();
}
}
private async Task receiveLoop()
{
byte[] buffer = new byte[2048];
while (true)
{
string json = string.Empty;
try
{
if (ws == null)
{
return;
}
if (ws.State != System.Net.WebSockets.WebSocketState.Open)
{
OnClose?.Invoke("");
return;
}
System.Net.WebSockets.WebSocketReceiveResult result = await ws.ReceiveAsync(new ArraySegment <byte>(buffer), src.Token);
json = Encoding.UTF8.GetString(buffer.Take(result.Count).ToArray());
var message = JsonConvert.DeserializeObject <SocketMessage>(json);
if (message != null)
{
_receiveQueue.Add(message);
}
await ProcessQueue();
}
catch (Exception ex)
{
if (ws.State != System.Net.WebSockets.WebSocketState.Open)
{
OnClose?.Invoke(ex.Message);
}
else
{
Log.Error(json);
Log.Error(ex, "");
}
}
}
}
static async Task TestConnection(string server)
{
using (var ws = new System.Net.WebSockets.Managed.ClientWebSocket())
{
await ws.ConnectAsync(new Uri(server), CancellationToken.None);
var buffer = new ArraySegment <byte>(new byte[1024]);
var readTask = ws.ReceiveAsync(buffer, CancellationToken.None);
const string msg = "hello";
var testMsg = new ArraySegment <byte>(Encoding.UTF8.GetBytes(msg));
await ws.SendAsync(testMsg, WebSocketMessageType.Text, true, CancellationToken.None);
var read = await readTask;
var reply = Encoding.UTF8.GetString(buffer.Array, 0, read.Count);
if (reply != msg)
{
throw new Exception($"Expected to read back '{msg}' but got '{reply}' for server {server}");
}
Console.WriteLine("Success connecting to server " + server);
}
}
public async Task <WebSocketReceiveResult> ReceiveAsync(ArraySegment <byte> buffer, CancellationToken cancellationToken)
{
return(await _ws.ReceiveAsync(buffer, cancellationToken).ConfigureAwait(false));
}
private async Task StartReceiving(ClientWebSocket client)
{
if (_result != null)
{
_result.Clear();
}
//单次完整数据
string msg = "";
while (true)
{
try
{
if (client.CloseStatus == WebSocketCloseStatus.EndpointUnavailable ||
client.CloseStatus == WebSocketCloseStatus.InternalServerError ||
client.CloseStatus == WebSocketCloseStatus.EndpointUnavailable)
{
return;
}
var array = new byte[4096];
var receive = await client.ReceiveAsync(new ArraySegment <byte>(array), CancellationToken.None);
if (receive.MessageType == WebSocketMessageType.Text)
{
if (receive.Count <= 0)
{
continue;
}
//string msg = Encoding.UTF8.GetString(array, 0, receive.Count);
//在Winform中无法把json一次完整接收，需要判断EndOfMessage的状态。
//临时不完整数据
string tempMsg = Encoding.UTF8.GetString(array, 0, receive.Count);
msg += tempMsg;
if (receive.EndOfMessage == false)
{
continue;
}
ASRResult result = JsonSerializer.Deserialize <ASRResult>(msg, new JsonSerializerOptions()
{
PropertyNameCaseInsensitive = true
});
//清空数据
msg = "";
if (result.Code != 0)
{
throw new Exception($"Result error({result.Code}): {result.Message}");
}
if (result.Data == null ||
result.Data.result == null ||
result.Data.result.ws == null)
{
return;
}
//分析数据
StringBuilder itemStringBuilder = new StringBuilder();
foreach (var item in result.Data.result.ws)
{
foreach (var child in item.cw)
{
if (string.IsNullOrEmpty(child.w))
{
continue;
}
itemStringBuilder.Append(child.w);
}
}
if (result.Data.result.pgs == "apd")
{
_result.Add(new ResultWPGSInfo()
{
sn = result.Data.result.sn,
data = itemStringBuilder.ToString()
});
}
else if (result.Data.result.pgs == "rpl")
{
if (result.Data.result.rg == null || result.Data.result.rg.Count != 2)
{
continue;
}
int first = result.Data.result.rg[0];
int end = result.Data.result.rg[1];
try
{
ResultWPGSInfo item = _result.Where(p => p.sn >= first && p.sn <= end).SingleOrDefault();
if (item == null)
{
continue;
}
else
{
item.sn = result.Data.result.sn;
item.data = itemStringBuilder.ToString();
}
}
catch
{
continue;
}
}
StringBuilder totalStringBuilder = new StringBuilder();
foreach (var item in _result)
{
totalStringBuilder.Append(item.data);
}
OnMessage?.Invoke(this, totalStringBuilder.ToString());
//最后一帧，结束
if (result.Data.status == 2)
{
return;
}
}
}
catch (WebSocketException)
{
return;
}
catch (Exception ex)
{
//服务器主动断开连接
if (!ex.Message.ToLower().Contains("unable to read data from the transport connection"))
{
OnError?.Invoke(this, new ErrorEventArgs()
{
Code = ResultCode.Error,
Message = ex.Message,
Exception = ex,
});
}
return;
}
}
}
//private async Task<WebSocketReceiveResult> SendCmdAsync(CdpMsg msg)
private async Task <string> SendCmdAsync(CdpMsg msg)
{
try
{
using (ClientWebSocket ws = new ClientWebSocket())
{
Log($"CdpClient.SendMsg(): Attempting to send cmd {msg.method}, port is {_chromeDebuggingPort}");
// load config
await CdpConfig.LoadConfigAsync().ConfigureAwait(false);
byte[] receiveBytes = new byte[65536];
var receiveBuffer = new ArraySegment <byte>(receiveBytes);
ws.Options.SetBuffer(65536, 65536); // (receive 64KB, send 64KB)
#if DEBUG
var tokenSource = new CancellationTokenSource(600000); // 10 mins
#else
var tokenSource = new CancellationTokenSource(10000); // 10 secs
#endif
CancellationToken cancellationToken = tokenSource.Token;
Uri wsUri;
if (msg.method.StartsWith("Browser"))
{
wsUri = this.CdpConfig.BrowserWsUri;
}
else
{
wsUri = this.CdpConfig.PageWsUri;
}
Log($"CdpClient.SendMsg(): Attempting to connect to uri {wsUri}, port is {_chromeDebuggingPort}...");
await ws.ConnectAsync(wsUri, cancellationToken).ConfigureAwait(false);
Log($"CdpClient.SendMsg(): ...Connected to to uri {wsUri}, port is {_chromeDebuggingPort}");
string json = Json.Serialize <CdpMsg>(msg);
byte[] bytes = Encoding.UTF8.GetBytes(json);
ArraySegment <byte> sendBuffer = new ArraySegment <byte>(bytes);
Log($"About to send CDP cmd {msg.method} to port {_chromeDebuggingPort}...");
await ws.SendAsync(sendBuffer, WebSocketMessageType.Text, true, cancellationToken).ConfigureAwait(false);
WebSocketReceiveResult result = await ws.ReceiveAsync(receiveBuffer, cancellationToken).ConfigureAwait(false);
Log($"...received CDP result for cmd {msg.method}, result = {Json.Serialize(result)}, port is {_chromeDebuggingPort}");
// retrive result from buffer
if (result.MessageType != WebSocketMessageType.Text)
{
return($"Unexpected message type: {result.MessageType}");
}
string msgText = Encoding.UTF8.GetString(receiveBytes, 0, result.Count);
Log($"{msg.method}(): returned result {msgText}, port is {_chromeDebuggingPort}");
return(msgText);
}
}
catch (Exception ex)
{
Log($"Exception occurred: {ex.ToString()}");
return(null);
}
}
private async Task ListenAsync()
{
while (true)
{
var buffer = new byte[ReceiveChunkSize];
int count = 0;
WebSocketReceiveResult result = null;
while (_ws.State == WebSocketState.Open)
{
try
{
//result = await _ws.ReceiveAsync(new ArraySegment<byte>(buffer), _wsWorkTokenSource.Token);
var subBuffer = new byte[ReceiveChunkSize];
result = await _ws.ReceiveAsync(new ArraySegment <byte>(subBuffer), CancellationToken.None);
if (result.MessageType == WebSocketMessageType.Close)
{
Close("io server disconnect");
break;
}
else if (result.MessageType == WebSocketMessageType.Text || result.MessageType == WebSocketMessageType.Binary)
{
if (buffer.Length - count < result.Count)
{
Array.Resize(ref buffer, buffer.Length + result.Count);
}
Buffer.BlockCopy(subBuffer, 0, buffer, count, result.Count);
count += result.Count;
}
if (result.EndOfMessage)
{
break;
}
}
catch (WebSocketException e)
{
Close(e.Message);
break;
}
}
if (result == null)
{
break;
}
if (result.MessageType == WebSocketMessageType.Text)
{
string message = Encoding.UTF8.GetString(buffer, 0, count);
#if DEBUG
System.Diagnostics.Trace.WriteLine($"⬇ {DateTime.Now} {message}");
#endif
processor.Process(new MessageContext
{
Message = message,
SocketIO = _io
});
}
else if (result.MessageType == WebSocketMessageType.Binary)
{
#if DEBUG
System.Diagnostics.Trace.WriteLine($"⬇ {DateTime.Now} Binary message");
#endif
byte[] bytes;
if (_io.Options.EIO == 3)
{
count -= 1;
bytes = new byte[count];
Buffer.BlockCopy(buffer, 1, bytes, 0, count);
}
else
{
bytes = new byte[count];
Buffer.BlockCopy(buffer, 0, bytes, 0, count);
}
_io.InvokeBytesReceived(bytes);
}
}
}
