public async Task SendMessageAsync(string text, CancellationToken cancellationToken)
{
if (_ws == null)
{
throw new InvalidSocketStateException("Faild to emit, websocket is not connected yet.");
}
if (_ws.State != WebSocketState.Open)
{
throw new InvalidSocketStateException("Connection is not open.");
}
byte[] bytes = Encoding.UTF8.GetBytes(text);
try
{
await sendLock.WaitAsync();
await _ws.SendAsync(new ArraySegment <byte>(bytes), WebSocketMessageType.Text, true, cancellationToken);
#if DEBUG
System.Diagnostics.Trace.WriteLine($"⬆ {DateTime.Now} {text}");
#endif
}
catch (TaskCanceledException)
{
#if DEBUG
System.Diagnostics.Trace.WriteLine($"❌ {DateTime.Now} Cancel \"{text}\"");
#endif
}
finally
{
sendLock.Release();
}
}
private async Task SendMessageAsync(byte[] messageBuffer)
{
var messagesCount = (int)Math.Ceiling((double)messageBuffer.Length / SendChunkSize);
try
{
if (_clientWebSocket.State != WebSocketState.Open)
{
throw new WebSocketException("Connection is not open.");
}
for (var i = 0; i < messagesCount; i++)
{
var offset = (SendChunkSize * i);
var count = SendChunkSize;
var lastMessage = ((i + 1) == messagesCount);
if ((count * (i + 1)) > messageBuffer.Length)
{
count = messageBuffer.Length - offset;
}
await _clientWebSocket.SendAsync(new ArraySegment <byte>(messageBuffer, offset, count), WebSocketMessageType.Text, lastMessage, _cancellationToken);
}
}
catch (Exception)
{
CallOnDisconnected();
}
}
private async Task SendSocketMessage(string json)
{
var bytes = Encoding.UTF8.GetBytes(json);
var arraySegment = new ArraySegment <byte>(bytes);
await _clientWebSocket.SendAsync(arraySegment, WebSocketMessageType.Binary, true, CancellationToken.None)
.ConfigureAwait(false);
}
private async Task <bool> SendString(string data, CancellationToken cancellation)
{
if (ws == null)
{
return(false);
}
if (ws.State != System.Net.WebSockets.WebSocketState.Open)
{
return(false);
}
var encoded = Encoding.UTF8.GetBytes(data);
var buffer = new ArraySegment <Byte>(encoded, 0, encoded.Length);
try
{
await SendStringSemaphore.WaitAsync();
//await ws.SendAsync(buffer, WebSocketMessageType.Text, true, cancellation);
await ws.SendAsync(buffer, System.Net.WebSockets.WebSocketMessageType.Text, true, cancellation);
return(true);
}
catch (Exception ex)
{
Log.Error(ex, "");
}
finally
{
SendStringSemaphore.Release();
}
return(false);
}
public async Task SendMessageAsync(string text, CancellationToken cancellationToken)
{
if (_ws == null)
{
throw new InvalidSocketStateException("Faild to emit, websocket is not connected yet.");
}
if (_ws.State != WebSocketState.Open)
{
throw new InvalidSocketStateException("Connection is not open.");
}
byte[] bytes = Encoding.UTF8.GetBytes(text);
await _ws.SendAsync(new ArraySegment <byte>(bytes), WebSocketMessageType.Text, true, cancellationToken);
#if DEBUG
Trace.WriteLine($"⬆ {DateTime.Now} {text}");
#endif
}
public void Send(string str)
{
ArraySegment <byte> bytesToSend = new ArraySegment <byte>(
Encoding.UTF8.GetBytes(str));
Task task = ws.SendAsync(
bytesToSend, WebSocketMessageType.Text,
true, CancellationToken.None);
task.Wait();
}
public async Task SendAsync(ArraySegment <byte> buffer, WebSocketMessageType messageType, bool endOfMessage, CancellationToken cancellationToken)
{
try
{
await _sendLock.WaitAsync().ConfigureAwait(false);
await _ws.SendAsync(buffer, messageType, endOfMessage, cancellationToken).ConfigureAwait(false);
}
finally
{
_sendLock.Release();
}
}
public async Task SendText(string text)
{
try
{
if (webSocket != null && webSocket.State == WebSocketState.Open)
{
ArraySegment <byte> textBytes = new ArraySegment <byte>(Encoding.UTF8.GetBytes(text));
await webSocket.SendAsync(textBytes, WebSocketMessageType.Text, true, CancellationToken.None);
}
}
catch (Exception)
{
}
}
private async Task SendMessageAsync(string text)
{
if (_socket.State == WebSocketState.Open)
{
var messageBuffer = Encoding.UTF8.GetBytes(text);
var messagesCount = (int)Math.Ceiling((double)messageBuffer.Length / SendChunkSize);
for (var i = 0; i < messagesCount; i++)
{
int offset = SendChunkSize * i;
int count = SendChunkSize;
bool isEndOfMessage = (i + 1) == messagesCount;
if ((count * (i + 1)) > messageBuffer.Length)
{
count = messageBuffer.Length - offset;
}
await _socket.SendAsync(new ArraySegment <byte>(messageBuffer, offset, count), WebSocketMessageType.Text, isEndOfMessage, _tokenSource.Token);
}
}
}
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);
}
}
/// <summary>
/// 语音转写一个完整的音频文件
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
public async Task <ResultModel <string> > ConvertAudio(byte[] data)
{
try
{
using (_ws = new ClientWebSocket())
{
Status = ServiceStatus.Running;
_host = ApiAuthorization.BuildAuthUrl(_settings);
await _ws.ConnectAsync(new Uri(_host), CancellationToken.None);
_receiveTask = StartReceiving(_ws);
//开始发送数据
for (int i = 0; i < data.Length; i += _frameSize)
{
byte[] buffer = SubArray(data, i, _frameSize);
if (buffer == null || data.Length - i < _frameSize)
{
_status = FrameState.Last; //文件读完
}
switch (_status)
{
case FrameState.First:
FirstFrameData firstFrame = new FirstFrameData
{
common = _common,
business = _business,
data = _data
};
firstFrame.data.status = FrameState.First;
firstFrame.data.audio = System.Convert.ToBase64String(buffer);
await _ws.SendAsync(new ArraySegment <byte>(Encoding.UTF8.GetBytes(JsonSerializer.Serialize(firstFrame)))
, WebSocketMessageType.Text
, true
, CancellationToken.None);
_status = FrameState.Continue;
break;
case FrameState.Continue: //中间帧
ContinueFrameData continueFrame = new ContinueFrameData
{
data = _data
};
continueFrame.data.status = FrameState.Continue;
continueFrame.data.audio = System.Convert.ToBase64String(buffer);
await _ws.SendAsync(new ArraySegment <byte>(Encoding.UTF8.GetBytes(JsonSerializer.Serialize(continueFrame)))
, WebSocketMessageType.Text
, true
, CancellationToken.None);
break;
case FrameState.Last: // 最后一帧音频
LastFrameData lastFrame = new LastFrameData
{
data = _data
};
lastFrame.data.status = FrameState.Last;
lastFrame.data.audio = System.Convert.ToBase64String(buffer);
await _ws.SendAsync(new ArraySegment <byte>(Encoding.UTF8.GetBytes(JsonSerializer.Serialize(lastFrame)))
, WebSocketMessageType.Text
, true
, CancellationToken.None);
break;
}
await Task.Delay(_intervel);
}
while (_receiveTask.Status != TaskStatus.RanToCompletion)
{
await Task.Delay(10);
}
await _ws.CloseAsync(WebSocketCloseStatus.NormalClosure, "NormalClosure", CancellationToken.None);
}
StringBuilder result = new StringBuilder();
foreach (var item in _result)
{
result.Append(item.data);
}
ResetState();
return(new ResultModel <string>()
{
Code = ResultCode.Success,
Data = result.ToString(),
});
}
catch (Exception ex)
{
return(new ResultModel <string>()
{
Code = ResultCode.Error,
Message = ex.Message,
});
}
}
private async Task <ResultModel <string> > DoFragmentAsr(byte[] data, FrameState state = FrameState.First)
{
try
{
if (_ws == null && _status == FrameState.First)
{
_ws = new ClientWebSocket();
_status = FrameState.First;
_host = ApiAuthorization.BuildAuthUrl(_settings);
await _ws.ConnectAsync(new Uri(_host), CancellationToken.None);
if (_ws.State != WebSocketState.Open)
{
throw new Exception("Connect to xfyun api server failed.");
}
_receiveTask = StartReceiving(_ws);
}
//开始发送数据
for (int i = 0; i < data.Length; i += _frameSize)
{
byte[] buffer = null;
if (_rest.Length == 0) //没有上次分片的数据
{
if (data.Length - i < _frameSize) //最后一帧不满一个完整的识别帧，那么加入缓存，下个分片的时候继续使用
{
if (state != FrameState.Last)
{
int length = data.Length - i;
Array.Copy(data, i, _rest.Cache, 0, length);
_rest.Length = length;
}
else
{
buffer = SubArray(data, i, _frameSize);
_status = FrameState.Last;
}
}
else
{
buffer = SubArray(data, i, _frameSize);
if (state == FrameState.Last && data.Length - i == _frameSize)
{
_status = FrameState.Last;
if (buffer == null)
{
buffer = new byte[1] {
0
};
}
}
}
}
else //有上次分片的数据
{
if (data.Length + _rest.Length <= _frameSize)
{
buffer = new byte[_rest.Length + data.Length];
Array.Copy(_rest.Cache, 0, buffer, 0, _rest.Length);
//最后分片加上缓存不满一个帧大小的情况
Array.Copy(data, i, buffer, _rest.Length, data.Length);
_status = FrameState.Last;
i = data.Length - _frameSize;
}
else
{
buffer = new byte[_frameSize];
Array.Copy(_rest.Cache, 0, buffer, 0, _rest.Length);
Array.Copy(data, i, buffer, _rest.Length, _frameSize - _rest.Length);
i -= _rest.Length;
}
_rest.Clear(); //清空
}
if (_rest.Length != 0)
{
break;
}
switch (_status)
{
case FrameState.First:
FirstFrameData firstFrame = new FirstFrameData
{
common = _common,
business = _business,
data = _data
};
firstFrame.data.status = FrameState.First;
firstFrame.data.audio = System.Convert.ToBase64String(buffer);
await _ws.SendAsync(new ArraySegment <byte>(Encoding.UTF8.GetBytes(JsonSerializer.Serialize(firstFrame)))
, WebSocketMessageType.Text
, true
, CancellationToken.None);
_status = FrameState.Continue;
break;
case FrameState.Continue: //中间帧
ContinueFrameData continueFrame = new ContinueFrameData
{
data = _data
};
continueFrame.data.status = FrameState.Continue;
continueFrame.data.audio = System.Convert.ToBase64String(buffer);
await _ws.SendAsync(new ArraySegment <byte>(Encoding.UTF8.GetBytes(JsonSerializer.Serialize(continueFrame)))
, WebSocketMessageType.Text
, true
, CancellationToken.None);
break;
case FrameState.Last: // 最后一帧音频
LastFrameData lastFrame = new LastFrameData
{
data = _data
};
lastFrame.data.status = FrameState.Last;
lastFrame.data.audio = System.Convert.ToBase64String(buffer);
await _ws.SendAsync(new ArraySegment <byte>(Encoding.UTF8.GetBytes(JsonSerializer.Serialize(lastFrame)))
, WebSocketMessageType.Text
, true
, CancellationToken.None);
break;
}
await Task.Delay(_intervel);
}
if (state == FrameState.Last)
{
while (_receiveTask.Status != TaskStatus.RanToCompletion)
{
await Task.Delay(10);
}
await _ws.CloseAsync(WebSocketCloseStatus.NormalClosure, "NormalClosure", CancellationToken.None);
}
return(new ResultModel <string>()
{
Code = ResultCode.Success,
Data = null,
});
}
catch (Exception ex)
{
//服务器主动断开连接或者自动断开连接了
if (ex.Message.ToLower().Contains("unable to read data from the transport connection"))
{
try
{
await _ws.CloseAsync(WebSocketCloseStatus.NormalClosure, "NormalClosure", CancellationToken.None);
}
catch { }
while (_receiveTask.Status != TaskStatus.RanToCompletion)
{
await Task.Delay(10);
}
return(new ResultModel <string>()
{
Code = ResultCode.Disconnect,
Message = "服务器主动断开连接，可能是整个会话是否已经超过了60s、读取数据超时、静默检测超时等原因引起的。",
});
}
else
{
return(new ResultModel <string>()
{
Code = ResultCode.Error,
Message = ex.Message,
});
}
}
}
//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);
}
}
