protected override void OnError (WebSocketSharp.ErrorEventArgs e)
{
Debug.Log ("WebSocket Error:");
Debug.Log (e.Message);
Debug.Log (e.Exception.Message);
Debug.Log (e.Exception.StackTrace);
}
void socket_OnMessage(object sender, WebSocketSharp.MessageEventArgs e)
{
if (OnReceive != null)
{
OnReceiveBytes(e.RawData);
}
}
private void webSocketClient_Closed(object sender, WebSocketSharp.CloseEventArgs e)
{
if (!webSocketClient.IsAlive)
{
isRecon = true;
webSocketClient.ConnectAsync();
}
}
public WebSocketClientChannel(WebSocketSharp.WebSocket socket)
{
this._socket = socket;
this._onClosed += (o, e) =>
{
this.Close(e.Reason);
};
}
protected override void OnMessage(WebSocketSharp.MessageEventArgs e)
{
var args = new DataReceivedArgs
{
Data = new ArraySegment<byte>(e.RawData, 0, e.RawData.Length),
SessionID = this
};
_source.FireRecieved(args);
}
protected override void OnMessage(WebSocketSharp.MessageEventArgs e)
{
base.OnMessage(e);
// if (e.Type == WebSocketSharp.Opcode.TEXT)
{
Console.WriteLine("\nWS=>COM:");
byte[] buffer = new byte[1024];
buffer = string2bytes(e.Data);// Encoding.UTF8.GetBytes(e.Data);
printHex(buffer);
SerialPortSingleton.GetInstance().Write(buffer, buffer.Length);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="NativeWebSocket" /> class.
/// </summary>
/// <param name="socket">The socket.</param>
/// <param name="logger">The logger.</param>
/// <exception cref="System.ArgumentNullException">socket</exception>
public SharpWebSocket(WebSocketSharp.WebSocket socket, ILogger logger)
{
if (socket == null)
{
throw new ArgumentNullException("socket");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
_logger = logger;
WebSocket = socket;
socket.OnMessage += socket_OnMessage;
socket.OnClose += socket_OnClose;
socket.OnError += socket_OnError;
WebSocket.ConnectAsServer();
}
private static void ws_OnError(object sender, WebSocketSharp.ErrorEventArgs e)
{
MessageBox.Show(e.Message);
}
protected override void OnClose(WebSocketSharp.CloseEventArgs e)
{
base.OnClose(e);
}
private void WebSocket_OnError(object sender, WebSocketSharp.ErrorEventArgs e)
{
Console.WriteLine(e.Message);
}
protected override void OnMessage(WebSocketSharp.MessageEventArgs e)
{
CommandRequestHandler.Handle(this, e.Data);
}
private void Message(System.Object sender, WebSocketSharp.MessageEventArgs e)
{
if (e.Type == Opcode.Text)
{
inboundQueue.Enqueue(e.Data);
}
else
{
Debug.Log("Unsupported type: " + e.Type);
}
}
protected void OnWebSocketError (object sender, WebSocketSharp.ErrorEventArgs e)
{
Debug.Log("[SnipeClient] OnWebSocketError: " + e.Message);
//DispatchEvent(ErrorHappened);
}
private void webSocketClient_Error(object sender, WebSocketSharp.ErrorEventArgs e)
{
}
/// <summary>
/// Event fired when the socket closed.
/// </summary>
/// <param name="sender">Sender.</param>
/// <param name="e">Eevent Arguments</param>
private void Socket_SocketError (object sender, WebSocketSharp.ErrorEventArgs args)
{
Console.WriteLine ("Socket Error:" + args.Message);
}
void socket_OnClose(object sender, WebSocketSharp.CloseEventArgs e)
{
EventHelper.FireEventIfNotNull(Closed, this, EventArgs.Empty, _logger);
}
protected override void OnMessage(WebSocketSharp.MessageEventArgs e)
{
NetIncomingMessage m = new NetIncomingMessage();
m.message = e.RawData;
m.messageLength = e.RawData.Length;
m.Type = NetworkMessageType.Data;
m.SenderConnection = connection;
Enqueue(m);
}
private void _ws_OnError(object sender, WebSocketSharp.ErrorEventArgs e) {
_st = State.NoAnswer;
if(_verbose.Value) {
Log.Warning("client - " + e.Message);
}
_reconn.Change(_rccnt * 15000 - (DateTime.Now.Ticks & 0x1FFF), _rccnt * 30000);
_callback(Event.Disconnected, null);
}
public WebSocketClientChannel(WebSocketSharp.WebSocket socket)
{
this._socket = socket;
}
private void Error(System.Object sender, WebSocketSharp.ErrorEventArgs e)
{
Debug.Log("Error: " + e.Message);
errors.Enqueue(e.Message);
}
void OnError(object sender, WebSocketSharp.ErrorEventArgs e)
{
Debug.Print("Errored " + e.Message);
try
{
JToken.Parse(e.Message);
RootObject RO = JsonConvert.DeserializeObject<RootObject>(e.Message);
if (RO.Error != null)
{
PrintMessage(DateTime.Now, "Server", RO.Error, eWsMessageType.ErrorMsg);
}
}
catch (Exception Ex)
{
PrintMessage(DateTime.Now, "Client", e.Exception.Message, eWsMessageType.ErrorMsg);
}
}
void OnLogMessage(WebSocketSharp.LogData logData, string message) {
Debug.LogWarning(logData.Message);
}
private void _ws_OnError(object sender, WebSocketSharp.ErrorEventArgs e) {
_st=State.NoAnswer;
if(_verbose.value) {
Log.Warning(name + " - " +e.Message);
}
_reconn.Change(_rccnt*15000, _rccnt*30000);
}
public void OnMessage(object sender, WebSocketSharp.MessageEventArgs messageEvent)
{
try
{
dynamic json = JsonConvert.DeserializeObject(messageEvent.Data);
string type = json.type;
if(type == "result")
{
string from = json.from;
bool result = json.result;
if(result == true && from == "bind")
{
bound = true;
FlushOutboundBacklog();
}
}
lock(instanceLock)
{
inboundBacklog.Add(messageEvent.Data);
}
}
catch(Exception e)
{
Log("Could not parse chat message: " + messageEvent.Data + ", Ex: " + e, LogLevel.Error);
}
}
internal static WsStream CreateServerStream(WebSocketSharp.Net.HttpListenerContext context)
{
var conn = context.Connection;
var stream = conn.Stream;
return conn.IsSecure
? new WsStream((SslStream)stream)
: new WsStream((NetworkStream)stream);
}
private void websocket_Error(object sender, WebSocketSharp.ErrorEventArgs e)
{
// TODO: What happens here? Do I need to re-connect, or do I just log the issue?
Pusher.LogWarning( "Websocket error: " + e.Message );
}
/// <summary>
/// Raw websocket messages from server - convert to message types and call subscribers of events and/or callbacks
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void wsClient_MessageReceived(object sender, WebSocketSharp.MessageEventArgs e)
{
//IMessage iMsg = SocketIOClient.Messages.Message.Factory(e.Message);
IMessage iMsg = SocketIOClient.Messages.Message.Factory(e.Data);
if (iMsg.Event == "responseMsg")
Trace.WriteLine(string.Format("InvokeOnEvent: {0}", iMsg.RawMessage));
switch (iMsg.MessageType)
{
case SocketIOMessageTypes.Disconnect:
this.OnMessageEvent(iMsg);
if (string.IsNullOrEmpty(iMsg.Endpoint)) // Disconnect the whole socket
this.Close();
break;
case SocketIOMessageTypes.Heartbeat:
this.OnHeartBeatTimerCallback(null);
break;
case SocketIOMessageTypes.Connect:
case SocketIOMessageTypes.Message:
case SocketIOMessageTypes.JSONMessage:
case SocketIOMessageTypes.Event:
case SocketIOMessageTypes.Error:
this.OnMessageEvent(iMsg);
break;
case SocketIOMessageTypes.ACK:
this.registrationManager.InvokeCallBack(iMsg.AckId, iMsg.Json);
break;
default:
Trace.WriteLine("unknown wsClient message Received...");
break;
}
}
/// <summary>
/// websocket has closed unexpectedly - retry connection
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void wsClient_Closed(object sender, WebSocketSharp.CloseEventArgs e)
{
if (this.retryConnectionCount < this.RetryConnectionAttempts )
{
this.ConnectionOpenEvent.Reset();
this.ReConnect();
}
else
{
this.Close();
this.OnSocketConnectionClosedEvent(this, EventArgs.Empty);
}
}
private void wsClient_Error(object sender, WebSocketSharp.ErrorEventArgs e)
{
this.OnErrorEvent(sender, new ErrorEventArgs(string.Format ("SocketClient error: {0}", e.Message)));
}
private void WebRtcStartCall(WebSocketSharp.Net.WebSockets.WebSocketContext context, string webSocketID)
{
logger.Debug("New WebRTC client added for web socket connection " + webSocketID + ".");
lock (_webRtcSessions)
{
if (!_webRtcSessions.Any(x => x.Key == webSocketID))
{
var webRtcSession = new WebRtcSession(webSocketID);
if (_webRtcSessions.TryAdd(webSocketID, webRtcSession))
{
webRtcSession.Peer.OnSdpOfferReady += (sdp) => { logger.Debug("Offer SDP: " + sdp); context.WebSocket.Send(sdp); };
webRtcSession.Peer.OnDtlsPacket += webRtcSession.DtlsPacketReceived;
webRtcSession.Peer.OnMediaPacket += webRtcSession.MediaPacketReceived;
webRtcSession.Peer.Initialise(DTLS_CERTIFICATE_THUMBRPINT, null);
webRtcSession.Peer.OnClose += () => { PeerClosed(webSocketID); };
}
else
{
logger.Error("Failed to add new WebRTC client to sessions dictionary.");
}
}
}
}
